Khi làm việc với các mô hình ngôn ngữ lớn như Claude từ Anthropic, việc hiểu số lượng token mà đầu vào của bạn tiêu thụ là rất cần thiết để quản lý chi phí và tối ưu hóa hiệu suất. Trong bài viết này, chúng ta sẽ tìm hiểu cách tính toán số lượng token cho một đầu vào nhất định bằng Go. Chúng ta sẽ sử dụng điểm cuối API count_tokens của Anthropic, cung cấp một cách đơn giản để xác định việc sử dụng token.

Điều kiện tiên quyết

Trước khi bắt đầu, hãy đảm bảo bạn có:

1. Môi trường Go hoạt động (hướng dẫn cài đặt).
2. Khóa API Anthropic. Đặt nó làm biến môi trường (ANTHROPIC_API_KEY).
3. Kiến thức cơ bản về các yêu cầu HTTP của Go và xử lý JSON.

Mã nguồn

Đây là một hàm Go hoàn chỉnh để tính toán số lượng token cho Claude:

package main

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"net/http"
	"os"
)

// RequestPayload định nghĩa cấu trúc của dữ liệu JSON
type RequestPayload struct {
	Model    string `json:"model"`
	System   string `json:"system"`
	Messages []struct {
		Role    string `json:"role"`
		Content string `json:"content"`
	} `json:"messages"`
}

// Response định nghĩa cấu trúc của phản hồi từ API
type Response struct {
	InputTokens int `json:"input_tokens"`
}

// CalculateToken tính toán số lượng token cho nội dung đầu vào nhất định
func CalculateToken(ctx context.Context, content string, encoding string) (int, error) {
	// Định nghĩa điểm cuối API và tiêu đề
	url := "https://api.anthropic.com/v1/messages/count_tokens"
	apiKey := os.Getenv("ANTHROPIC_API_KEY") // Đảm bảo điều này được đặt trong môi trường của bạn
	headers := map[string]string{
		"x-api-key":         apiKey,
		"content-type":      "application/json",
		"anthropic-version": "2023-06-01",
		"anthropic-beta":    "token-counting-2024-11-01",
	}

	// Tạo dữ liệu yêu cầu
	payload := RequestPayload{
		Model:  encoding,
		System: "Bạn là một nhà khoa học",
		Messages: []struct {
			Role    string `json:"role"`
			Content string `json:"content"`
		}{
			{Role: "user", Content: content},
		},
	}

	// Chuyển đổi dữ liệu thành JSON
	payloadBytes, err := json.Marshal(payload)
	if err != nil {
		log.Fatalf("Lỗi chuyển đổi dữ liệu: %v", err)
	}

	// Tạo yêu cầu HTTP POST
	req, err := http.NewRequest("POST", url, bytes.NewBuffer(payloadBytes))
	if err != nil {
		log.Fatalf("Lỗi tạo yêu cầu HTTP: %v", err)
	}

	// Thêm tiêu đề vào yêu cầu
	for key, value := range headers {
		req.Header.Set(key, value)
	}

	// Gửi yêu cầu
	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		log.Fatalf("Lỗi gửi yêu cầu: %v", err)
	}
	defer resp.Body.Close()

	// Đọc và phân tích phản hồi
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("Lỗi đọc nội dung phản hồi: %v", err)
		return 0, err
	}

	respData := &Response{}
	_ = json.Unmarshal(body, respData)
	fmt.Printf("Trạng thái phản hồi: %s\n", resp.Status)
	fmt.Printf("Nội dung phản hồi: %s\n", body)

	return respData.InputTokens, nil
}

Giải thích

1. Cấu trúc dữ liệu

Cấu trúc RequestPayload định nghĩa dữ liệu JSON cần thiết cho API count_tokens. Trường Messages chứa lịch sử cuộc trò chuyện, trong đó mỗi tin nhắn có một vai trò (ví dụ: người dùng) và nội dung.

2. Định nghĩa điểm cuối API và tiêu đề

Chúng ta sử dụng url cho điểm cuối đếm token và cung cấp các tiêu đề cần thiết, bao gồm:

• x-api-key: Khóa API của bạn.
• content-type: Đặt thành application/json.
• anthropic-version và anthropic-beta: Chỉ định phiên bản API và tính năng beta để đếm token.

3. Thực hiện yêu cầu API

Hàm:

1. Chuyển đổi dữ liệu thành JSON.
2. Tạo một yêu cầu POST với dữ liệu đã được chuyển đổi.
3. Đặt các tiêu đề cần thiết.
4. Xử lý phản hồi

Phản hồi được đọc và chuyển đổi thành cấu trúc Response, trích xuất trường input_tokens.

Ví dụ sử dụng

Đây là cách bạn có thể sử dụng hàm CalculateToken:

func main() {
	ctx := context.Background()
	content := "Xin chào! Vậy đoạn văn bản này tiêu thụ bao nhiêu token?"
	encoding := "claude-2" // Thay thế bằng tên mô hình mong muốn

	tokens, err := CalculateToken(ctx, content, encoding)
	if err != nil {
		log.Fatalf("Không thể tính toán token: %v", err)
	}

	fmt.Printf("Nội dung đầu vào tiêu thụ %d token.\n", tokens)
}

Kết quả

Việc chạy ví dụ sẽ xuất ra một cái gì đó như:

Trạng thái phản hồi: 200 OK
Nội dung phản hồi: {"input_tokens": 12}
Nội dung đầu vào tiêu thụ 12 token.

Bằng cách làm theo hướng dẫn này, bạn có thể liền mạch tích hợp việc đếm token vào các ứng dụng Go của mình và quản lý tốt hơn sự tương tác của bạn với Claude.