如何用 Go 建立可編輯程式碼的 Claude 智能體
How to Build an Agent
Thorsten Ball 示範以 Go 和 Anthropic API 建立可編輯程式碼的 Claude 智能體,並以迴圈處理對話及工具呼叫。示範加入 read_file、list_files 和 edit_file,讓模型讀取及列出檔案,並按指令建立或修改檔案;工具結果會送回模型。程式碼不到 400 行。
文章以不到 400 行 Go 程式碼,逐步組裝可讀取、列出及編輯檔案的 Claude 智能體,呈現工具定義與執行結果回傳的基本循環。
Thorsten Ball//2025 年 4 月 15 日
或者:皇帝的新衣
要打造一個功能齊全、能編輯程式碼的 Agent,並沒有那麼困難。
看起來可能很困難。當你看到 Agent 編輯檔案、執行指令、從錯誤中脱困,並嘗試不同策略時,會覺得背後一定有甚麼秘訣。
其實沒有。它只是一個 LLM、一個循環,以及足夠的 tokens。從一開始,我們就在Podcast上這樣説。至於其他部分,那些令Amp如此令人上癮、如此出色的東西?全靠埋頭苦幹。
但要打造一個小巧而令人印象深刻的 Agent,甚至不需要這些。不到 400 行程式碼就能做到,而大部分都只是樣板程式碼。
我現在就會示範給你看。我們一起寫一些程式碼,從零行程式碼開始,直到你驚嘆:「哇,這……真是改變一切。」
我強烈建議你跟着一起做。不,真的。你可能覺得只要閲讀本文就可以,不用親手輸入程式碼,但這不到 400 行。我希望你能親身感受程式碼有多精簡,也希望你能在自己的終端機、自己的資料夾裏親眼看到這一切。
我們需要以下東西:
- Go
- Anthropic API 金鑰,並將它設為環境變數,
ANTHROPIC_API_KEY
拿出鉛筆!
我們馬上開始,用四個簡單指令設定一個新的 Go 專案:
mkdir code-editing-agent
cd code-editing-agent
go mod init agent
touch main.go現在,開啟 main.go,第一步先在裏面放入所需內容的骨架:
package main
import (
"bufio"
"context"
"fmt"
"os"
"github.com/anthropics/anthropic-sdk-go"
)
func main() {
client := anthropic.NewClient()
scanner := bufio.NewScanner(os.Stdin)
getUserMessage := func() (string, bool) {
if !scanner.Scan() {
return "", false
}
return scanner.Text(), true
}
agent := NewAgent(&client, getUserMessage)
err := agent.Run(context.TODO())
if err != nil {
fmt.Printf("Error: %s\n", err.Error())
}
}
func NewAgent(client *anthropic.Client, getUserMessage func() (string, bool)) *Agent {
return &Agent{
client: client,
getUserMessage: getUserMessage,
}
}
type Agent struct {
client *anthropic.Client
getUserMessage func() (string, bool)
}沒錯,這還不能編譯。不過,我們現在有一個 Agent,它可以存取 anthropic.Client(預設會尋找 ANTHROPIC_API_KEY),而且可以從終端機的 stdin 讀取用戶訊息。
現在加入缺少的 Run() 方法:
// main.go
func (a *Agent) Run(ctx context.Context) error {
conversation := []anthropic.MessageParam{}
fmt.Println("Chat with Claude (use 'ctrl-c' to quit)")
for {
fmt.Print("\\u001b[94mYou\\u001b[0m: ")
userInput, ok := a.getUserMessage()
if !ok {
break
}
userMessage := anthropic.NewUserMessage(anthropic.NewTextBlock(userInput))
conversation = append(conversation, userMessage)
message, err := a.runInference(ctx, conversation)
if err != nil {
return err
}
conversation = append(conversation, message.ToParam())
for _, content := range message.Content {
switch content.Type {
case "text":
fmt.Printf("\\u001b[93mClaude\\u001b[0m: %s\n", content.Text)
}
}
}
return nil
}
func (a *Agent) runInference(ctx context.Context, conversation []anthropic.MessageParam) (*anthropic.Message, error) {
message, err := a.client.Messages.New(ctx, anthropic.MessageNewParams{
Model: anthropic.ModelClaude3_7SonnetLatest,
MaxTokens: int64(1024),
Messages: conversation,
})
return message, err
}不算多,對吧?90 行,而其中最重要的部分,就是 Run() 裏這個讓我們與 Claude 對話的循環。不過,這已經是這個程式的心跳。
至於這個心跳,運作方式相當簡單:我們先顯示提示,請用戶輸入內容,把訊息加入對話,傳送給 Claude,再把 Claude 的回覆加入對話,顯示回覆,然後不斷循環。
這就是你用過的每款 AI 聊天應用程式,只不過它是在終端機裏運作。
我們來執行它:
export ANTHROPIC_API_KEY="this is the last time i will tell you to set this"
# Download the dependencies
go mod tidy
# Run it
go run main.go接着,你就可以像這樣跟 Claude 對話:
$ go run main.go
與 Claude 對話(輸入 'ctrl-c' 結束)
你:嗨!我是 Thorsten!你最近怎樣?
Claude:你好,Thorsten!我很好,謝謝你問候。很高興認識你。你今天過得怎樣?有甚麼我可以幫忙嗎?
你:你能想出一些跟馬有關、可以取笑我名字的綽號嗎?
Claude:我可以試着根據「Thorsten」想出一些跟馬有關、帶點玩笑意味的綽號: * Thorough-bred Thorsten * Trotsten * Thorsten the Stallion * Neighsten * Horseten * Thorsten the Galloper * Saddle-sten * Thorsten of the Mane * Canter-sten * Thorsteed 這些綽號只是想帶來輕鬆的笑意,希望能逗你一笑!
你:
留意我們如何在多個回合中延續同一段對話。Claude 記得我在第一則訊息中提過的名字。每個回合之後,conversation 都會變長,而我們每次都會傳送整段對話。伺服器——也就是 Anthropic 的伺服器——是無狀態的。它只會看到 conversation 片段中的內容。維持這段對話的工作就由我們負責。
好,繼續吧,因為這些暱稱很糟糕,而且這還未算是一個 Agent。甚麼是 Agent?以下是我的定義:一個能夠使用工具的 LLM,讓它可以修改上下文視窗以外的內容。
第一個工具
一個能夠使用工具的 LLM?甚麼是工具?基本概念是這樣:你向模型傳送提示詞,告訴它如果想使用「工具」,就要以特定方式回覆。然後,你作為訊息的接收者,就透過執行「工具」並回覆結果來「使用工具」。就是這樣。我們接下來會看到的其他內容,都只是在這個基礎上加一層抽象。
想像一下,你正在跟朋友交談,並告訴他:「接下來的對話中,如果你想讓我舉起手臂,就眨眨眼。」這話説起來有點奇怪,但概念很容易理解。
我們現在就可以試試,不用改動任何程式碼。
$ go run main.go
與 Claude 對話(按 'ctrl-c' 結束)
你:你是一位天氣專家。當我詢問某個地點的天氣時,我希望你以 `get_weather(<location_name>)` 回覆。之後我會告訴你該地點的天氣狀況。明白嗎?
Claude:我明白你的指示。當你詢問特定地點的天氣時,我會以 `get_weather(<location_name>)` 回覆。然後你會告訴我該地點的天氣資訊,我可以再和你討論。我已準備好,隨時可以回答你對任何地方天氣的提問。
你:嘿,慕尼黑的天氣怎樣?
Claude:get_weather(Munich)
我們告訴 Claude,當它想知道天氣時,就用 get_weather 眨眼。下一步是舉起手臂,並回覆「工具的結果」:
你:炎熱潮濕,28 攝氏度
Claude:多謝你提供這些資訊。慕尼黑目前天氣炎熱潮濕,氣温為 28 攝氏度(約 82 華氏度)。對慕尼黑而言,這算是相當温暖的天氣;加上濕度較高,體感温度可能會比實際氣温更高。 如果你身在慕尼黑或正計劃前往,最好補充水分、穿著輕便衣物,並考慮在一天中最熱的時段安排室內活動。炎熱潮濕的天氣可能相當令人不適,尤其是對不習慣這種天氣的人來説。 你想知道其他地方的天氣嗎?
一次就成功了,效果很好,對吧?
這些模型經過訓練和微調,能夠使用「工具」,而且非常樂於這樣做。到了 2025 年,它們某程度上已「知道」自己並非無所不知,並可以使用工具取得更多資訊。(當然,實際情況並不完全是這樣,但暫時這樣解釋已經足夠。)
總括而言,工具和工具的使用只涉及兩件事:
- 你告訴模型有哪些工具可用
- 模型想執行工具時,會告訴你;你執行工具,再把回應傳回模型
為了更容易做到(1),大型模型供應商已建立內置 API,讓你一併傳送工具定義。
好,現在來建立我們的第一個工具:read_file
read_file 工具
要定義 read_file 工具,我們會使用 Anthropic SDK 建議的類型,但請記住:在底層,這些內容最終都會變成傳送給模型的字串。整個機制就只是「如果你想讓我使用 read_file,就眨眼」。
我們要加入的每個工具都需要以下內容:
- 一個名稱
- 用來向模型説明工具的功能、何時應使用或不應使用、會回傳甚麼等資訊的描述
- 一份輸入結構描述,以 JSON Schema 格式説明此工具預期接收哪些輸入,以及各輸入的格式
- 一個函式,會使用模型傳給我們的輸入實際執行工具,並回傳結果
現在把它加入程式碼:
// main.go
type ToolDefinition struct {
Name string `json:"name"`
Description string `json:"description"`
InputSchema anthropic.ToolInputSchemaParam `json:"input_schema"`
Function func(input json.RawMessage) (string, error)
}現在提供我們的 Agent 工具定義:
// main.go
// `tools` is added here:
type Agent struct {
client *anthropic.Client
getUserMessage func() (string, bool)
tools []ToolDefinition
}
// And here:
func NewAgent(
client *anthropic.Client,
getUserMessage func() (string, bool),
tools []ToolDefinition,
) *Agent {
return &Agent{
client: client,
getUserMessage: getUserMessage,
tools: tools,
}
}
// And here:
func main() {
// [... previous code ...]
tools := []ToolDefinition{}
agent := NewAgent(&client, getUserMessage, tools)
// [... previous code ...]
}再透過 runInference 將它們傳給模型:
// main.go
func (a *Agent) runInference(ctx context.Context, conversation []anthropic.MessageParam) (*anthropic.Message, error) {
anthropicTools := []anthropic.ToolUnionParam{}
for _, tool := range a.tools {
anthropicTools = append(anthropicTools, anthropic.ToolUnionParam{
OfTool: &anthropic.ToolParam{
Name: tool.Name,
Description: anthropic.String(tool.Description),
InputSchema: tool.InputSchema,
},
})
}
message, err := a.client.Messages.New(ctx, anthropic.MessageNewParams{
Model: anthropic.ModelClaude3_7SonnetLatest,
MaxTokens: int64(1024),
Messages: conversation,
Tools: anthropicTools,
})
return message, err
}這裏有不少型別方面的複雜操作,而我對 Go 泛型還不太熟,所以不打算向你解釋 anthropic.String 和 ToolUnionParam。不過,我保證,真的很簡單:
我們會一併傳送工具定義;在伺服器端,Anthropic 會把這些定義包裝在這個系統提示詞中(內容不多),再將它加入我們的 conversation。如果模型想使用該工具,就會以特定方式回覆。
好,工具定義已經一併傳送,但我們還未定義工具。現在就來定義 read_file:
// main.go
var ReadFileDefinition = ToolDefinition{
Name: "read_file",
Description: "Read the contents of a given relative file path. Use this when you want to see what's inside a file. Do not use this with directory names.",
InputSchema: ReadFileInputSchema,
Function: ReadFile,
}
type ReadFileInput struct {
Path string `json:"path" jsonschema_description:"The relative path of a file in the working directory."`
}
var ReadFileInputSchema = GenerateSchema[ReadFileInput]()
func ReadFile(input json.RawMessage) (string, error) {
readFileInput := ReadFileInput{}
err := json.Unmarshal(input, &readFileInput)
if err != nil {
panic(err)
}
content, err := os.ReadFile(readFileInput.Path)
if err != nil {
return "", err
}
return string(content), nil
}
func GenerateSchema[T any]() anthropic.ToolInputSchemaParam {
reflector := jsonschema.Reflector{
AllowAdditionalProperties: false,
DoNotReference: true,
}
var v T
schema := reflector.Reflect(v)
return anthropic.ToolInputSchemaParam{
Properties: schema.Properties,
}
}內容不多,對吧?它只有一個函式 ReadFile,以及模型會看到的兩段描述:我們的 Description 用來描述工具本身("Read the contents of a given relative file path. ..."),另一段則描述這個工具唯一的輸入參數("The relative path of a ...")。
ReadFileInputSchema 和 GenerateSchema 那些東西?我們需要它們來為工具定義產生 JSON Schema,然後傳給模型。為此,我們會使用 jsonschema 套件,因此需要先匯入並下載:
// main.go
package main
import (
"bufio"
"context"
// Add this:
"encoding/json"
"fmt"
"os"
"github.com/anthropics/anthropic-sdk-go"
// Add this:
"github.com/invopop/jsonschema"
)然後執行以下指令:
go mod tidy接着,在 main 函式中,我們要確保使用這個定義:
func main() {
// [... previous code ...]
tools := []ToolDefinition{ReadFileDefinition}
// [... previous code ...]
}是時候試試了!
$ go run main.go
與 Claude 對話(使用 'ctrl-c' 離開)
你:main.go 裏有甚麼?
Claude:我會幫你查看 main.go 檔案的內容。我來讀給你聽。
你:
等等,甚麼?呵,呵,呵,它想使用工具!你的輸出當然會略有不同,但聽起來 Claude 確實知道自己可以讀取檔案,對吧?
問題是我們沒有聽!Claude 眨眼示意時,我們卻置之不理。我們得修正這點。
讓我示範如何用一個簡單、快速,而且以我這把年紀來説出奇敏捷的動作做到這點:把我們的 Agent 的 Run 方法替換成以下內容:
// main.go
func (a *Agent) Run(ctx context.Context) error {
conversation := []anthropic.MessageParam{}
fmt.Println("Chat with Claude (use 'ctrl-c' to quit)")
readUserInput := true
for {
if readUserInput {
fmt.Print("\\u001b[94mYou\\u001b[0m: ")
userInput, ok := a.getUserMessage()
if !ok {
break
}
userMessage := anthropic.NewUserMessage(anthropic.NewTextBlock(userInput))
conversation = append(conversation, userMessage)
}
message, err := a.runInference(ctx, conversation)
if err != nil {
return err
}
conversation = append(conversation, message.ToParam())
toolResults := []anthropic.ContentBlockParamUnion{}
for _, content := range message.Content {
switch content.Type {
case "text":
fmt.Printf("\\u001b[93mClaude\\u001b[0m: %s\n", content.Text)
case "tool_use":
result := a.executeTool(content.ID, content.Name, content.Input)
toolResults = append(toolResults, result)
}
}
if len(toolResults) == 0 {
readUserInput = true
continue
}
readUserInput = false
conversation = append(conversation, anthropic.NewUserMessage(toolResults...))
}
return nil
}
func (a *Agent) executeTool(id, name string, input json.RawMessage) anthropic.ContentBlockParamUnion {
var toolDef ToolDefinition
var found bool
for _, tool := range a.tools {
if tool.Name == name {
toolDef = tool
found = true
break
}
}
if !found {
return anthropic.NewToolResultBlock(id, "tool not found", true)
}
fmt.Printf("\\u001b[92mtool\\u001b[0m: %s(%s)\n", name, input)
response, err := toolDef.Function(input)
if err != nil {
return anthropic.NewToolResultBlock(id, err.Error(), true)
}
return anthropic.NewToolResultBlock(id, response, false)
}眯起眼仔細看,就會發現九成是樣板程式碼,只有一成是重點:收到 Claude 傳回的 message 時,我們會查看是否有 content.Type == "tool_use",以判斷 Claude 是否要求我們執行工具;如果有,就交由 executeTool 處理,按名稱在本機註冊清單中查找工具、反序列化輸入、執行工具並回傳結果。如果出錯,就切換一個布林值。就這樣。
(沒錯,雖然有一個迴圈套着另一個迴圈,但這不重要。)
我們執行工具,把結果傳回 Claude,再次詢問 Claude 的回覆。真的,就是這樣。我示範給你看。
準備好後,執行:
echo 'what animal is the most disagreeable because it always says neigh?' >> secret-file.txt這會在我們的目錄中建立一個 secret-file.txt,裏面有一道神秘謎題。
現在就在同一個目錄中執行這個可以使用工具的新 Agent,並叫它查看檔案:
$ go run main.go
與 Claude 對話(使用 'ctrl-c' 離開)
你:Claude,老友,幫我解開 secret-file.txt 檔案裏的謎題
Claude:我會幫你解開 secret-file.txt 檔案裏的謎題。我先讀取檔案內容,看看謎題是甚麼。
工具: read_file({"path":"secret-file.txt"})
Claude:太好了!我找到這個謎語了。 謎底是:**一匹馬** 這個謎語運用了雙關語:「neigh」(馬發出的叫聲)聽起來跟「nay」(表示「不」或反對的説法)相似。因此,謎語説馬總是唱反調,因為牠們總是説「neigh/nay」,暗示牠們總是在反對別人。
你:
我們先深呼吸,然後一起説。準備好了嗎?來吧:我靠。你只要給它一個工具,而它……在認為有助於完成任務時就會使用該工具。記住:我們沒有説過任何關於「如果用戶問你某個檔案的事,就讀取該檔案」的話。我們也沒有説「如果某樣東西看起來像檔名,就想辦法讀取它」。不,完全沒有。我們只説「幫我解決這個檔案中的問題」,Claude 就會想到可以讀取檔案來回答,然後便開始處理。
當然,我們可以講得具體些,並大力引導它使用某個工具,但基本上它會自行完成所有事情:
$ go run main.go
與 Claude 對話(輸入 'ctrl-c' 退出)
你:main.go 裏發生了甚麼事?簡短回答!
Claude:我會查看 main.go 檔案,瞭解其中的內容。
tool:read_file({"path":"main.go"})
Claude:根據我的檢視,main.go 實作了一個能使用工具的 Claude AI 助手 Agent。簡要概述如下: - 使用 Anthropic Go SDK 建立與 Claude 對話的命令列介面 - 實作工具系統,其中只有一個用來讀取檔案內容的「read_file」工具 - 管理與 Claude 的對話流程,處理一般文字回應和工具使用請求 - Claude 要求使用工具時,Agent 會執行該工具並返回結果 - 程式會持續循環以維持對話,直到用戶退出 簡而言之,這段程式碼建立了一個簡單的 CLI 聊天機械人,Claude 提出要求時,它便能與檔案系統互動。
你:
完全正確。好,現在我們知道如何讓 Claude 使用工具,就再加幾個。
list_files 工具
如果你跟我一樣,登入新電腦後第一件事就是執行 ls — 列出檔案,瞭解一下目前的環境。
讓 Claude 也具備同樣的能力,加入一個列出檔案的工具。以下是 list_files 工具的完整實作:
// main.go
var ListFilesDefinition = ToolDefinition{
Name: "list_files",
Description: "List files and directories at a given path. If no path is provided, lists files in the current directory.",
InputSchema: ListFilesInputSchema,
Function: ListFiles,
}
type ListFilesInput struct {
Path string `json:"path,omitempty" jsonschema_description:"Optional relative path to list files from. Defaults to current directory if not provided."`
}
var ListFilesInputSchema = GenerateSchema[ListFilesInput]()
func ListFiles(input json.RawMessage) (string, error) {
listFilesInput := ListFilesInput{}
err := json.Unmarshal(input, &listFilesInput)
if err != nil {
panic(err)
}
dir := "."
if listFilesInput.Path != "" {
dir = listFilesInput.Path
}
var files []string
err = filepath.Walk(dir, func(path string, info os.FileInfo, err error) error {
if err != nil {
return err
}
relPath, err := filepath.Rel(dir, path)
if err != nil {
return err
}
if relPath != "." {
if info.IsDir() {
files = append(files, relPath+"/")
} else {
files = append(files, relPath)
}
}
return nil
})
if err != nil {
return "", err
}
result, err := json.Marshal(files)
if err != nil {
return "", err
}
return string(result), nil
}這裏沒有甚麼花巧之處:list_files 會返回目前資料夾中的檔案和目錄清單。如果這是認真的專案,我們還可以(而且大概應該)進行一大堆優化;不過我只是想展示魔術師帽子裏有甚麼,所以這樣已經足夠。
有一點要注意:我們返回字串清單,並在目錄名稱末尾加上斜線。這並非必要,只是我自行決定這樣做。格式沒有固定要求,只要 Claude 能理解,任何格式都可以。至於它是否能理解,則需要透過實驗找出答案。你也可以在每個目錄前加上 "directory: ",或返回一份包含兩個標題的 Markdown 文件:"directories" 和 "files"。選擇很多,取決於哪種格式最容易讓 Claude 理解、需要多少 token、生成和讀取的速度等。
在這裏,我們只想建立一個小型 list_files 工具,所以最簡單的做法就是最佳選擇。
當然,我們也要告訴 Claude list_files 是甚麼:
// main.go
func main() {
// [... previous code ...]
tools := []ToolDefinition{ReadFileDefinition, ListFilesDefinition}
// [... previous code ...]
}就這樣。問問 Claude 在這個目錄中看到了甚麼。
$ go run main.go
與 Claude 對話(輸入 'ctrl-c' 退出)
你:你在這個目錄中看到甚麼?
Claude:我來幫你查看目前目錄中的內容。我會列出檔案和目錄。
工具:list_files({})
Claude:我在目前目錄中看到幾個檔案和目錄: 1. 與 Git 相關的檔案和目錄: - `.git/` 目錄,內有各種 Git 設定和追蹤檔案 - `.gitignore` 檔案 2. Go 專案檔案: - `main.go` - Go 主要原始程式碼檔案 - `go.mod` - Go 模組定義檔案 - `go.sum` - Go 模組校驗和檔案 3. 文件: - `blogpost.md` - Markdown 檔案,可能載有網誌內容 4. 環境設定: - `.envrc` - 可能是環境設定檔案 你想我查看這份清單中的哪個特定檔案嗎?
你:
成功!它可以讀取目錄。
但關鍵是:Claude 知道如何組合這些工具。我們只需要用能促使它這樣做的方式提示它:
$ go run main.go
與 Claude 對話(使用 'ctrl-c' 退出)
你:簡短介紹一下這裏所有的 Go 檔案!
Claude:我來查看目前目錄中的 Go 檔案。首先讓我看看有哪些檔案。
工具:list_files({})
Claude:我在目前目錄中找到一個 Go 檔案。讓我查看一下:
工具:read_file({"path":"main.go"})
工具:read_file({"path":"go.mod"})
Claude:以下簡要介紹這個專案中的 Go 檔案: **main.go**: - 實作一個 Claude AI Agent,可與本機檔案系統互動 - 使用 Anthropic 的 Go SDK 與 Claude AI 模型通訊 - 提供兩種工具:`read_file` 和 `list_files`,讓 Claude 讀取檔案內容及列出目錄內容 - 管理用戶與 Claude 之間的對話流程,並在 Claude 需要存取檔案時處理工具執行 **go.mod**: - 定義模組依賴項目 - 主要依賴項目是 Anthropic 的 Go SDK 和一個 JSON schema 程式庫 - 使用 Go 1.24.1 這看來是一個簡單的終端機應用程式,讓用戶可以與 Claude 對話,同時讓 AI 讀取本機檔案及列出目錄。
你:
它先使用了 list_files,然後用與 Go 相關、而且是我問到的檔案呼叫了 read_file 兩次。
就……就跟我們會做的一樣,對吧?我的意思是,如果我問你這個專案使用哪個版本的 Go,你會怎樣做?以下是 Claude 為我做的事:
$ go run main.go
與 Claude 對話(使用 'ctrl-c' 退出)
你:這個專案使用哪個版本的 Go?
Claude:我來幫你找出這個專案使用的 Go 版本。我會查看檔案,找出可能註明 Go 版本的位置。
工具:list_files({})
Claude:我看到這裏是一個 Go 專案,有幾個重要檔案,例如 `go.mod`、`go.sum` 和 `main.go`。我先查看 `go.mod` 檔案,因為 Go 版本通常會在這裏註明。
工具:read_file({"path":"go.mod"})
Claude:根據 `go.mod` 檔案,這個專案使用 Go 1.24.1。
Claude 查看目錄,再查看 go.mod,便得出答案。
目前程式碼大約有190行。好好消化一下。消化完之後,我們再加入另一個工具。
讓它 edit_file
我們要加入的最後一個工具是 edit_file — 一個讓 Claude 編輯檔案的工具。
你現在大概會想:「我的天,這就是真正考驗開始的地方,也就是他要變出兔子的時候。」好吧,我們來看看?
首先,為新的 edit_file 工具加入定義:
// main.go
var EditFileDefinition = ToolDefinition{
Name: "edit_file",
Description: `Make edits to a text file.
Replaces 'old_str' with 'new_str' in the given file. 'old_str' and 'new_str' MUST be different from each other.
If the file specified with path doesn't exist, it will be created.
`,
InputSchema: EditFileInputSchema,
Function: EditFile,
}
type EditFileInput struct {
Path string `json:"path" jsonschema_description:"The path to the file"`
OldStr string `json:"old_str" jsonschema_description:"Text to search for - must match exactly and must only have one match exactly"`
NewStr string `json:"new_str" jsonschema_description:"Text to replace old_str with"`
}
var EditFileInputSchema = GenerateSchema[EditFileInput]()沒錯,我又知道你在想甚麼:「用字串取代來編輯
檔案?」Claude 3.7 很喜歡取代字串(要了解它們喜歡甚麼或不喜歡甚麼,就得透過實驗),所以我們會透過告訴 Claude 可以用新文字取代現有文字來編輯檔案,從而實作 edit_file。
以下是 EditFile 函式的 Go 實作:
func EditFile(input json.RawMessage) (string, error) {
editFileInput := EditFileInput{}
err := json.Unmarshal(input, &editFileInput)
if err != nil {
return "", err
}
if editFileInput.Path == "" || editFileInput.OldStr == editFileInput.NewStr {
return "", fmt.Errorf("invalid input parameters")
}
content, err := os.ReadFile(editFileInput.Path)
if err != nil {
if os.IsNotExist(err) && editFileInput.OldStr == "" {
return createNewFile(editFileInput.Path, editFileInput.NewStr)
}
return "", err
}
oldContent := string(content)
newContent := strings.Replace(oldContent, editFileInput.OldStr, editFileInput.NewStr, -1)
if oldContent == newContent && editFileInput.OldStr != "" {
return "", fmt.Errorf("old_str not found in file")
}
err = os.WriteFile(editFileInput.Path, []byte(newContent), 0644)
if err != nil {
return "", err
}
return "OK", nil
}它會檢查輸入參數、讀取檔案(或在檔案已存在時建立檔案),並以 NewStr 取代 OldStr。然後,它會將內容寫回磁碟,並傳回 "OK"。
還欠缺的是 createNewFile,這只是一個小型輔助函式;如果不是用 Go 寫的話,程式碼可以短70%:
func createNewFile(filePath, content string) (string, error) {
dir := path.Dir(filePath)
if dir != "." {
err := os.MkdirAll(dir, 0755)
if err != nil {
return "", fmt.Errorf("failed to create directory: %w", err)
}
}
err := os.WriteFile(filePath, []byte(content), 0644)
if err != nil {
return "", fmt.Errorf("failed to create file: %w", err)
}
return fmt.Sprintf("Successfully created file %s", filePath), nil
}最後一步:將它加入我們傳送給 Claude 的工具清單。
// main.go
func main() {
// [... previous code ...]
tools := []ToolDefinition{ReadFileDefinition, ListFilesDefinition, EditFileDefinition}
// [... previous code ...]
}然後……我們準備好了,不過你準備好了嗎?你準備好放手一試了嗎?
我就知道。來吧,告訴 Claude 用 JavaScript 建立一個新的 FizzBuzz 函式。
$ go run main.go
與 Claude 聊天(使用 'ctrl-c' 結束)
你:嘿,Claude,建立 fizzbuzz.js,讓我可以用 Nodejs 執行,而且檔案內要有並執行 FizzBuzz
Claude:我會建立一個可用 Node.js 執行的 fizzbuzz.js 檔案。首先,我來檢查這個檔案是否已存在:
工具:list_files({})
Claude:我找不到 fizzbuzz.js 檔案,所以會建立一個包含經典 FizzBuzz 實作的檔案。這個程式會輸出1至100的數字;但遇到3的倍數時會輸出「Fizz」,遇到5的倍數時會輸出「Buzz」,而遇到同時是3和5的倍數時則會輸出「FizzBuzz」。
工具:edit_file({"path":"fizzbuzz.js","old_str":"","new_str":"/**\n * FizzBuzz implementation in JavaScript\n * Prints numbers from 1 to 100, but:\n * - For multiples of 3, print \"Fizz\" instead of the number\n * - For multiples of 5, print \"Buzz\" instead of the number\n * - For multiples of both 3 and 5, print \"FizzBuzz\"\n */\n\nfunction fizzBuzz(n) {\n for (let i = 1; i <= n; i++) {\n let output = '';\n \n if (i % 3 === 0) output += 'Fizz';\n if (i % 5 === 0) output += 'Buzz';\n \n console.log(output || i);\n }\n}\n\n// Execute FizzBuzz for numbers 1 to 100\nconsole.log('Running FizzBuzz:');\nfizzBuzz(100);"}
Claude:我已建立可用 Node.js 執行的 fizzbuzz.js 檔案。這個程式: 1. 定義一個名為 `fizzBuzz` 的函式,接受參數 `n` 作為上限 2. 從1迴圈至 n(執行時設定為100) 3. 對每個數字: - 如果可以被3整除,就在輸出中加入「Fizz」 - 如果可以被5整除,就在輸出中加入「Buzz」 - 如果同時可以被3和5整除,就同時加入兩者,組成「FizzBuzz」 - 如果不能被3或5整除,就輸出數字本身 4. 指令碼會自動執行函式,處理1至100的數字 你可以在終端機中使用以下指令,透過 Node.js 執行這個指令碼: node fizzbuzz.js 這會在你的主控台輸出1至100的 FizzBuzz 數列。
對吧?!很厲害,對不對?而這大概就是你能想到的最基本 edit_file 實作——一般 Agent 的最基本實作。
但它有成功嗎?有,成功了:
$ node fizzbuzz.js
Running FizzBuzz:
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
16
[...]太厲害了。不過,讓我們試試叫它真正編輯檔案,而不只是建立檔案。
以下是我請 Claude「請編輯 fizzbuzz.js,讓它只輸出至 15」時,它的做法:
$ go run main.go
與 Claude 對話(使用 'ctrl-c' 離開)
你:請編輯 fizzbuzz.js,讓它只輸出至 15
Claude:我會編輯 fizzbuzz.js 檔案,將輸出上限改為 15。首先,讓我查看檔案目前的內容,瞭解需要作出哪些修改。
tool:read_file({"path":"fizzbuzz.js"})
Claude:我看到檔案目前會執行 FizzBuzz 至 100。我會修改 fizzBuzz 函式呼叫中的參數,將上限改為 15。
tool:edit_file({"path":"fizzbuzz.js","old_str":"// Execute FizzBuzz for numbers 1 to 100\nconsole.log('Running FizzBuzz:');\nfizzBuzz(100);","new_str":"// Execute FizzBuzz for numbers 1 to 15\nconsole.log('Running FizzBuzz:');\nfizzBuzz(15);"})
Claude:我還需要更新檔案頂部的註解,以反映這項修改:
tool:edit_file({"path":"fizzbuzz.js","old_str":"/**\n * FizzBuzz implementation in JavaScript\n * Prints numbers from 1 to 100, but:","new_str":"/**\n * FizzBuzz implementation in JavaScript\n * Prints numbers from 1 to 15, but:"})
Claude:已成功修改 fizzbuzz.js 檔案。程式現在會: 1. 只輸出 1 至 15 的 FizzBuzz(而非 1 至 100) 2. 更新説明文件以反映這項修改 函式本身維持不變,因為它會透過參數設定上限;我們只是將該參數由 100 改為 15。
它會讀取檔案,編輯檔案以改變程式執行至哪個數字,而且還會編輯檔案,更新頂部的註解。
而且仍然可以正常運作:
$ node fizzbuzz.js
Running FizzBuzz:
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz好,再試一次,請它完成以下工作:
建立一個 congrats.js 指令碼,對以下字串進行 ROT13 解碼並輸出:‘Pbatenghyngvbaf ba ohvyqvat n pbqr-rqvgvat ntrag!’
這個要求可能有點高。看看吧:
$ go run main.go
與 Claude 對話(使用 'ctrl-c' 離開)
你:建立一個 congrats.js 指令碼,對以下字串進行 ROT13 解碼並輸出:'Pbatenghyngvbaf ba ohvyqvat n pbqr-rqvgvat ntrag!'
Claude:我會建立一個 congrats.js 指令碼,解碼 ROT13 編碼的字串並將結果輸出。ROT13 是一種簡單的字母替換密碼,會把字母替換成字母表中其後第 13 個字母。 讓我為你建立這個檔案:
tool: edit_file({"path":"congrats.js","old_str":"","new_str":"/**\n * A script to decode a ROT13-encoded string and print the result\n */\n\nfunction rot13Decode(encodedStr) {\n return encodedStr.replace(/[a-zA-Z]/g, function(char) {\n // Get the character code\n const charCode = char.charCodeAt(0);\n \n // Handle uppercase letters\n if (charCode >= 65 && charCode <= 90) {\n return String.fromCharCode(((charCode - 65 + 13) % 26) + 65);\n }\n \n // Handle lowercase letters\n if (charCode >= 97 && charCode <= 122) {\n return String.fromCharCode(((charCode - 97 + 13) % 26) + 97);\n }\n \n // Return non-alphabetic characters as is\n return char;\n });\n}\n\nconst encodedMessage = 'Pbatenghyngvbaf ba ohvyqvat n pbqr-rqvgvat ntrag!';\nconst decodedMessage = rot13Decode(encodedMessage);\n\nconsole.log(decodedMessage);"})
Claude: 我已建立一個名為 congrats.js 的 JavaScript 檔案,當中: 1. 定義 `rot13Decode` 函數,接收一個已編碼字串,並套用 ROT13 密碼進行解碼 2. 使用提供的字串 'Pbatenghyngvbaf ba ohvyqvat n pbqr-rqvgvat ntrag!' 3. 使用該函數解碼 4. 將解碼後的訊息輸出至主控台 你可以在終端機輸入 `node congrats.js`,使用 Node.js 執行此指令碼。指令碼會解碼並顯示隱藏的祝賀訊息!
它行得通嗎?試試看:
$ node congrats.js
Congratulations on building a code-editing agent!成功了!
這不是很神奇嗎?
如果你跟我過去幾個月談過的所有工程師一樣,很可能你讀到這裏時,一直在等我把兔子從帽子裏變出來,等我説:「嗯,實際上事情要困難得多得多。」但事實並非如此。
這基本上就是程式碼編輯 Agent 內部循環的全部內容。當然,要把它整合到編輯器、調整系統提示詞、在適當時候給它適當的回饋、為它設計出色的使用者介面、為各種工具打造更完善的配套工具、支援多個 Agent 等等——我們已經在 Amp 裏完成了所有這些工作,但這並不需要靈光一閃。所需的只是實際的工程技術和埋頭苦幹。
這些模型現在的能力非常強大。只需 300 行程式碼和三個工具,你現在就能跟一個會編輯你程式碼的外星智慧對話。如果你心想「嗯,但我們其實沒有真的……」——就去試試看!看看用這個方法能做到甚麼程度。我敢説,你能做到的遠比你想像中多。
這就是我們認為一切正在改變的原因。
來源:Amp Chronicle · ampcode.com