从一个简单的翻译程序看大模型集成开发的未来

本文将以一个基于自部署大模型的简单翻译程序 translate.go 为例，探讨大模型集成开发的现状、意义以及未来发展趋势。该程序利用 Ollama API 与一个名为 Gemma 的大模型进行交互，实现中英文互译。虽然功能简单，但它体现了大模型集成开发的核心要素，并为我们理解未来趋势提供了 valuable insights。

程序功能与实现:

package main

import (
	"bytes"
	"encoding/json"
	"flag"
	"fmt"
	"io"
	"net/http"
	"os"
	"strings"
	"unicode"
)

type OllamaRequest struct {
	Model  string `json:"model"`
	Prompt string `json:"prompt"`
	Stream bool   `json:"stream"`
	Format string `json:"format"`
}

// OllamaResponseStream is used for streaming responses, which Gemma doesn't support in the same way as llama2
type OllamaResponseStream struct {
	Model              string `json:"model"`
	Response           string `json:"response"`
	Done               bool   `json:"done"`
	Context            []int  `json:"context"`
	TotalDuration      int    `json:"total_duration"`
	LoadDuration       int    `json:"load_duration"`
	PromptEvalCount    int    `json:"prompt_eval_count"`
	PromptEvalDuration int    `json:"prompt_eval_duration"`
	EvalCount          int    `json:"eval_count"`
	EvalDuration       int    `json:"eval_duration"`
}

// TranslationResponse is the struct for the desired JSON output
type TranslationResponse struct {
	Translation string `json:"translation"`
}

// isChinese checks if a string contains Chinese characters.
func isChinese(s string) bool {
	for _, r := range s {
		if unicode.Is(unicode.Han, r) {
			return true
		}
	}
	return false
}

func main() {
	var (
		model     string
		ollamaURL string
		input     string
	)

	// Set the default model to gemma3:4b
	flag.StringVar(&model, "model", "gemma3:4b", "Ollama model name")
	flag.StringVar(&ollamaURL, "url", "http://localhost:11434/api/generate", "Ollama API URL")
	flag.StringVar(&input, "input", "", "Input string to translate")
	flag.Parse()

	if input == "" {
		fmt.Fprintf(os.Stderr, "Error: Input string is required. Use -input \"your text\"\n")
		flag.Usage()
		os.Exit(1)
	}

	// Determine the source language and construct the appropriate prompt
	var prompt string
	if isChinese(input) {
		prompt = fmt.Sprintf("Translate the following Chinese text to English concisely:\n%s", input)
	} else {
		prompt = fmt.Sprintf("Translate the following English text to Chinese concisely:\n%s", input)
	}

	requestBody := OllamaRequest{
		Model:  model,
		Prompt: prompt,
		Stream: false, // Set stream to false for Gemma
		Format: "json",
	}

	jsonBody, err := json.Marshal(requestBody)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error marshaling JSON: %v\n", err)
		os.Exit(1)
	}

	resp, err := http.Post(ollamaURL, "application/json", bytes.NewBuffer(jsonBody))
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error sending request to Ollama: %v\n", err)
		os.Exit(1)
	}
	defer resp.Body.Close()

	if resp.StatusCode != http.StatusOK {
		fmt.Fprintf(os.Stderr, "Ollama request failed with status: %s\n", resp.Status)
		os.Exit(1)
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error reading response body: %v\n", err)
		os.Exit(1)
	}

	// Gemma returns a stream of JSON objects, even when stream is false.
	// We need to concatenate the "response" fields until "done" is true.
	var fullResponse strings.Builder
	decoder := json.NewDecoder(bytes.NewReader(body))
	for {
		var streamResponse OllamaResponseStream
		if err := decoder.Decode(&streamResponse); err != nil {
			if err == io.EOF {
				break
			}
			fmt.Fprintf(os.Stderr, "Error decoding stream JSON: %v\n", err)
			os.Exit(1)
		}
		fullResponse.WriteString(streamResponse.Response)
		if streamResponse.Done {
			break
		}
	}

	// Remove leading and trailing whitespace from the response
	trimmedResponse := strings.TrimSpace(fullResponse.String())

	// Check if the response is a valid JSON string, if so, extract the translation
	// First, check if the response itself is a JSON string
	if strings.HasPrefix(trimmedResponse, "{") && strings.HasSuffix(trimmedResponse, "}") {
		var tempMap map[string]string
		if err := json.Unmarshal([]byte(trimmedResponse), &tempMap); err == nil {
			if val, ok := tempMap["translation"]; ok {
				trimmedResponse = val
			} else {
				// If there is no "translation" key, it may be a stringified JSON
				// Try to unmarshal the value of the "response" key
				if val, ok := tempMap["response"]; ok {
					var innerMap map[string]string
					if err := json.Unmarshal([]byte(val), &innerMap); err == nil {
						if innerVal, innerOk := innerMap["translation"]; innerOk {
							trimmedResponse = innerVal
						} else {
							trimmedResponse = val
						}
					} else {
						trimmedResponse = val
					}
				}
			}
		}
	}

	// Create the TranslationResponse struct
	translationResponse := TranslationResponse{
		Translation: trimmedResponse,
	}

	// Marshal the struct to JSON
	jsonOutput, err := json.Marshal(translationResponse)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error marshaling JSON output: %v\n", err)
		os.Exit(1)
	}

	// Write the JSON output to stdout
	_, err = io.WriteString(os.Stdout, string(jsonOutput))
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error writing to output: %v\n", err)
		os.Exit(1)
	}
}

translate.go 程序的核心功能是将输入文本翻译成另一种语言。它首先判断输入文本是中文还是英文，然后构造相应的提示词（prompt），发送给 Ollama API，最终将翻译结果以 JSON 格式输出。程序巧妙地处理了 Gemma 模型返回的流式 JSON 数据，并对结果进行了清洗和格式化。

程序的关键部分在于与 Ollama API 的交互。Ollama 作为一个大模型的运行环境，简化了模型的部署和调用过程。程序通过 HTTP POST 请求发送包含模型名称、提示词和格式信息的 JSON 数据，接收模型的翻译结果。这体现了大模型集成开发中 API 调用的重要性，也是未来大模型应用开发的主流方式。

学习意义与价值:

这个简单的翻译程序，虽然功能有限，但其学习价值不容忽视：

• 理解大模型 API 调用:  程序清晰地展示了如何通过 HTTP 请求与大模型进行交互，这对于理解大模型的应用开发至关重要。
• 处理流式数据:  Gemma 模型返回流式 JSON 数据，程序有效地处理了这种数据格式，这在实际应用中非常常见。
• 错误处理与容错:  程序包含了完善的错误处理机制，这对于保证程序稳定性和可靠性至关重要。
• 提示词工程 (Prompt Engineering):  程序根据输入文本的语言自动生成不同的提示词，这体现了提示词工程在提高大模型输出质量中的作用。

大模型集成开发的流行趋势:

随着大模型能力的不断提升，以及像 Ollama 这样的易用工具的出现，大模型集成开发将成为一种流行趋势。这主要体现在以下几个方面：

• 降低开发门槛:  像 Ollama 这样的平台简化了大模型的部署和调用过程，降低了开发门槛，使更多开发者能够轻松地集成大模型到自己的应用中。
• 提高开发效率:  通过 API 调用，开发者可以专注于应用逻辑的开发，而无需关心底层模型的细节。
• 促进应用创新:  大模型强大的能力为各种应用场景带来了无限可能，例如翻译、文本生成、代码生成、问答等等。

未来展望:

未来，大模型集成开发将朝着以下方向发展：

• 更完善的 API 和工具:  将会有更多更完善的 API 和工具出现，进一步简化大模型的集成过程。
• 更强大的模型:  大模型的能力将不断提升，能够处理更复杂的任务，并提供更精准的结果。
• 更广泛的应用场景:  大模型将被集成到越来越多的应用中，改变我们的生活和工作方式。
• 更注重安全性与隐私:  随着大模型应用的普及，安全性与隐私问题将受到越来越多的关注。

总而言之，translate.go 这个简单的翻译程序，虽然功能简单，但却为我们理解大模型集成开发的现状和未来趋势提供了 valuable insights。随着技术的不断发展，大模型集成开发必将成为软件开发领域的重要组成部分，为我们带来更加智能和便捷的应用体验。