go语言使用 zhinao-go 轻松调用 360智脑

go语言使用 zhinao-go 轻松调用 360智脑

项目简介

zhinao-go 是一个专为 Go 开发者设计的 360智脑 SDK，提供简洁的 API 接口来访问 360智脑的 AI 能力。

核心特性：

• 简洁易用：环境变量便捷初始化，一行代码即可创建客户端
• Builder 模式：流畅的链式调用，轻松构建复杂请求
• 自动重试：内置智能重试机制，自动处理临时性错误

支持功能：

• 聊天补全（普通/流式响应）
• 工具调用（Function Calling）
• 文本生成图像（多种风格）
• 向量生成（Embeddings）
• 模型信息查询

安装使用

# 安装
go get github.com/lin-coco/zhinao-go

# 设置 API Key
export ZHINAO_API_KEY="your-api-key-here"

示例展示

1. 基础聊天补全

最简单的聊天补全示例，发送单个消息并获取 AI 回复。

package main

import (
    "context"
    "fmt"
    "github.com/lin-coco/zhinao-go"
)

func main() {
    client, err := zhinao.NewClientFromEnv()
    if err != nil {
       fmt.Printf("NewClientFromEnv error: %v\n", err)
       return
    }

    resp, err := client.Chat.CreateCompletion(
       context.Background(),
       &zhinao.ChatRequest{
          Model: zhinao.Model360GPTTurbo,
          Messages: []zhinao.Message{
             {
                Role:    zhinao.RoleUser,
                Content: "你好，请介绍一下360智脑",
             },
          },
       },
    )
    if err != nil {
       fmt.Printf("ChatCompletion error: %v\n", err)
       return
    }

    fmt.Println(resp.Choices[0].Message.Content)
}

2. 交互式聊天机器人

实现一个可以持续对话的聊天机器人，支持多轮对话和上下文记忆。

package main

import (
    "bufio"
    "context"
    "fmt"
    "os"

    "github.com/lin-coco/zhinao-go"
)

func main() {
    client, err := zhinao.NewClientFromEnv()
    if err != nil {
       fmt.Printf("NewClientFromEnv error: %v\n", err)
       return
    }

    messages := []zhinao.Message{
       {
          Role:    zhinao.RoleSystem,
          Content: "你是一个helpful的AI助手",
       },
    }

    fmt.Println("聊天机器人 (输入 'exit' 退出)")
    fmt.Println("---------------------")
    fmt.Print("> ")

    scanner := bufio.NewScanner(os.Stdin)
    for scanner.Scan() {
       userInput := scanner.Text()
       if userInput == "exit" {
          fmt.Println("再见!")
          break
       }

       // 添加用户消息
       messages = append(messages, zhinao.Message{
          Role:    zhinao.RoleUser,
          Content: userInput,
       })

       // 调用 API
       resp, err := client.Chat.CreateCompletion(
          context.Background(),
          &zhinao.ChatRequest{
             Model:    zhinao.Model360GPTTurbo,
             Messages: messages,
          },
       )
       if err != nil {
          fmt.Printf("ChatCompletion error: %v\n", err)
          fmt.Print("> ")
          continue
       }

       // 显示助手回复
       assistantMsg := resp.Choices[0].Message.Content
       fmt.Printf("%s\n\n", assistantMsg)

       // 添加助手消息到历史
       messages = append(messages, zhinao.Message{
          Role:    zhinao.RoleAssistant,
          Content: assistantMsg,
       })

       fmt.Print("> ")
    }
}

3. 流式响应

演示如何使用流式 API 实时接收 AI 响应，适合需要即时反馈的场景。

package main

import (
    "context"
    "fmt"
    "github.com/lin-coco/zhinao-go"
    "io"
)

func main() {
    client, err := zhinao.NewClientFromEnv()
    if err != nil {
       fmt.Printf("NewClientFromEnv error: %v\n", err)
       return
    }

    req := &zhinao.ChatRequest{
       Model: zhinao.Model360GPTTurbo,
       Messages: []zhinao.Message{
          {
             Role:    zhinao.RoleUser,
             Content: "请写一首关于春天的诗",
          },
       },
       Stream: true,
    }

    stream, err := client.Chat.CreateCompletionStream(context.Background(), req)
    if err != nil {
       fmt.Printf("CreateCompletionStream error: %v\n", err)
       return
    }
    defer stream.Close()

    fmt.Println("流式响应:")
    fmt.Println("---------------------")

    for {
       resp, err := stream.Recv()
       if err == io.EOF {
          fmt.Println("\n\n流式响应完成")
          break
       }
       if err != nil {
          fmt.Printf("\nStream error: %v\n", err)
          return
       }

       if len(resp.Choices) > 0 {
          fmt.Print(resp.Choices[0].Delta.Content)
       }
    }
}

4. 工具调用（Function Calling）

展示如何使用工具调用功能，让 AI 能够调用外部函数来获取信息或执行操作。

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "github.com/lin-coco/zhinao-go"
)

func main() {
    client, err := zhinao.NewClientFromEnv()
    if err != nil {
       fmt.Printf("NewClientFromEnv error: %v\n", err)
       return
    }

    // 定义天气查询工具
    weatherTool := zhinao.Tool{
       Type: "function",
       Function: zhinao.ToolFunction{
          Name:        "get_current_weather",
          Description: "获取指定城市的当前天气",
          Parameters: map[string]interface{}{
             "type": "object",
             "properties": map[string]interface{}{
                "location": map[string]interface{}{
                   "type":        "string",
                   "description": "城市名称，例如：北京、上海",
                },
                "unit": map[string]interface{}{
                   "type": "string",
                   "enum": []string{"celsius", "fahrenheit"},
                },
             },
             "required": []string{"location"},
          },
       },
    }

    // 初始对话
    messages := []zhinao.Message{
       {
          Role:    zhinao.RoleUser,
          Content: "北京今天天气怎么样？",
       },
    }

    fmt.Println("询问 AI: '北京今天天气怎么样？'")
    fmt.Println("提供工具: get_current_weather()")

    // 第一次调用：AI 决定是否使用工具
    resp, err := client.Chat.CreateCompletion(
       context.Background(),
       &zhinao.ChatRequest{
          Model:    zhinao.Model360GPTTurbo,
          Messages: messages,
          Tools:    []zhinao.Tool{weatherTool},
       },
    )
    if err != nil {
       fmt.Printf("ChatCompletion error: %v\n", err)
       return
    }

    msg := resp.Choices[0].Message

    // 检查 AI 是否请求调用工具
    if len(msg.ToolCalls) == 0 {
       fmt.Printf("\nAI 直接回复: %s\n", msg.Content)
       return
    }

    // AI 请求调用工具
    toolCall := msg.ToolCalls[0]
    fmt.Printf("\nAI 请求调用工具: %s\n", toolCall.Function.Name)
    fmt.Printf("参数: %s\n", toolCall.Function.Arguments)

    // 解析参数
    var params map[string]interface{}
    if err := json.Unmarshal([]byte(toolCall.Function.Arguments), &params); err != nil {
       fmt.Printf("Parse arguments error: %v\n", err)
       return
    }

    // 模拟调用天气 API
    weatherResult := map[string]interface{}{
       "location":    params["location"],
       "temperature": 22,
       "unit":        "celsius",
       "description": "晴朗",
    }
    weatherJSON, _ := json.Marshal(weatherResult)

    fmt.Printf("\n模拟工具返回: %s\n", string(weatherJSON))

    // 将工具调用和结果添加到对话历史
    messages = append(messages, msg)
    messages = append(messages, zhinao.Message{
       Role:       zhinao.RoleTool,
       Content:    string(weatherJSON),
       Name:       toolCall.Function.Name,
       ToolCallID: toolCall.ID,
    })

    // 第二次调用：让 AI 根据工具结果给出最终答案
    fmt.Println("\n请求 AI 基于工具结果回答原始问题...")
    resp, err = client.Chat.CreateCompletion(
       context.Background(),
       &zhinao.ChatRequest{
          Model:    zhinao.Model360GPTTurbo,
          Messages: messages,
          Tools:    []zhinao.Tool{weatherTool},
       },
    )
    if err != nil {
       fmt.Printf("ChatCompletion error: %v\n", err)
       return
    }

    fmt.Printf("\nAI 最终回复: %s\n", resp.Choices[0].Message.Content)
}

5. Builder 模式

演示如何使用链式 Builder 模式构建请求，提供更流畅的 API 使用体验。

package main

import (
    "context"
    "fmt"
    "github.com/lin-coco/zhinao-go"
)

func main() {
    client, err := zhinao.NewClientFromEnv()
    if err != nil {
       fmt.Printf("NewClientFromEnv error: %v\n", err)
       return
    }

    // 使用 Builder 模式构建请求
    req := zhinao.NewChatBuilder().
       SetModel(zhinao.Model360GPTTurbo).
       AddSystemMessage("你是一个专业的技术顾问，擅长解释复杂的技术概念").
       AddUserMessage("请用简单的语言解释什么是机器学习").
       SetTemperature(0.7).
       SetMaxTokens(500).
       SetTopP(0.9).
       Build()

    fmt.Println("使用 Builder 模式构建的请求:")
    fmt.Printf("- Model: %s\n", req.Model)
    fmt.Printf("- Temperature: %.1f\n", req.Temperature)
    fmt.Printf("- MaxTokens: %d\n", req.MaxTokens)
    fmt.Printf("- TopP: %.1f\n", req.TopP)
    fmt.Printf("- Messages: %d 条\n\n", len(req.Messages))

    resp, err := client.Chat.CreateCompletion(context.Background(), req)
    if err != nil {
       fmt.Printf("ChatCompletion error: %v\n", err)
       return
    }

    fmt.Println("AI 回复:")
    fmt.Println("---------------------")
    fmt.Println(resp.Choices[0].Message.Content)
    fmt.Printf("\n使用 Token 数: %d\n", resp.Usage.TotalTokens)
}

6. 模型列表

展示如何获取可用模型列表和查询特定模型信息。

package main

import (
    "context"
    "fmt"
    "github.com/lin-coco/zhinao-go"
    "log"
)

func main() {
    client, err := zhinao.NewClientFromEnv()
    if err != nil {
       log.Fatal(err)
    }

    fmt.Println("=== 获取可用模型列表 ===")

    // 获取模型列表
    models, err := client.Models.List(context.Background())
    if err != nil {
       log.Fatalf("获取模型列表失败: %v\n", err)
    }

    fmt.Printf("找到 %d 个可用模型:\n\n", len(models.Data))

    // 打印模型列表
    for i, model := range models.Data {
       fmt.Printf("%d. %s\n", i+1, model.ID)
       fmt.Printf("   类型: %s\n", model.Object)
       fmt.Printf("   所有者: %s\n", model.OwnedBy)
       fmt.Println()
    }

    // 获取特定模型的详细信息
    if len(models.Data) > 0 {
       modelID := models.Data[0].ID
       fmt.Printf("=== 获取模型 '%s' 的详细信息 ===\n\n", modelID)

       info, err := client.Models.Get(context.Background(), modelID)
       if err != nil {
          log.Fatalf("获取模型信息失败: %v\n", err)
       }

       fmt.Printf("模型 ID: %s\n", info.ID)
       fmt.Printf("类型: %s\n", info.Object)
       fmt.Printf("所有者: %s\n", info.OwnedBy)
    }

    // 也可以直接查询指定模型
    fmt.Println("\n=== 查询指定模型 ===")

    turboInfo, err := client.Models.Get(context.Background(), zhinao.Model360GPTTurbo)
    if err != nil {
       log.Printf("获取 %s 模型失败: %v\n", zhinao.Model360GPTTurbo, err)
    } else {
       fmt.Printf("✓ %s 可用\n", turboInfo.ID)
       fmt.Printf("  所有者: %s\n", turboInfo.OwnedBy)
    }
}

7. 文本生成图像

展示如何使用文本生成图像功能，支持多种风格和参数配置。

package main

import (
    "context"
    "fmt"
    "log"
    "os"

    "github.com/lin-coco/zhinao-go"
)

func main() {
    client, err := zhinao.NewClientFromEnv()
    if err != nil {
       log.Fatalf("Failed to create client: %v", err)
    }

    ctx := context.Background()

    fmt.Println("=== 360智脑文本生成图像示例 ===\n")

    // 示例 1: 基础图像生成
    fmt.Println("1. 基础图像生成（写实风格）")
    basicReq := &zhinao.Text2ImgRequest{
       Model:  zhinao.Model360CVW0V5,
       Style:  zhinao.StyleRealistic,
       Prompt: "一只可爱的小猫在草地上玩耍，阳光明媚，高清照片",
    }

    resp, err := client.Images.Text2Img(ctx, basicReq)
    if err != nil {
       log.Printf("Error: %v\n", err)
    } else {
       saveImage(resp, "example1_basic.png")
    }

    // 示例 2: 使用负向提示词
    fmt.Println("2. 使用负向提示词")
    negativeReq := &zhinao.Text2ImgRequest{
       Model:          zhinao.Model360CVW0V5,
       Style:          zhinao.StyleRealistic,
       Prompt:         "美丽的风景画，山川河流，蓝天白云",
       NegativePrompt: "模糊，低质量，变形，扭曲",
    }

    resp, err = client.Images.Text2Img(ctx, negativeReq)
    if err != nil {
       log.Printf("Error: %v\n", err)
    } else {
       saveImage(resp, "example2_negative_prompt.png")
    }

    // 示例 3: 多种风格
    styles := []struct {
       style string
       name  string
    }{
       {zhinao.StyleCartoon, "cartoon"},
       {zhinao.StyleCG, "cg"},
       {zhinao.StylePapercut, "papercut"},
    }

    fmt.Println("3. 多种风格示例")
    for _, s := range styles {
       req := &zhinao.Text2ImgRequest{
          Model:  zhinao.Model360CVW0V5,
          Style:  s.style,
          Prompt: "一只可爱的熊猫在竹林里",
       }

       resp, err := client.Images.Text2Img(ctx, req)
       if err != nil {
          log.Printf("Error generating %s style: %v\n", s.name, err)
       } else {
          filename := fmt.Sprintf("example3_%s.png", s.name)
          saveImage(resp, filename)
       }
    }
}

func saveImage(resp *zhinao.Text2ImgResponse, filename string) {
    if len(resp.Data) == 0 {
       log.Printf("No images in response\n")
       return
    }

    err := os.WriteFile(filename, resp.Data[0].ImageData, 0644)
    if err != nil {
       log.Printf("Failed to save %s: %v\n", filename, err)
       return
    }

    fmt.Printf("✅ 图像已保存: %s\n", filename)
}

8. 向量生成（Embeddings）

展示如何生成文本向量，用于语义搜索、文本分类等应用。

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/lin-coco/zhinao-go"
)

func main() {
    client, err := zhinao.NewClientFromEnv()
    if err != nil {
       log.Fatalf("Failed to create client: %v", err)
    }

    ctx := context.Background()

    fmt.Println("=== 360智脑向量生成示例 ===")
    fmt.Println()

    // 示例 1: 基础向量生成
    fmt.Println("1. 基础向量生成")
    basicReq := &zhinao.EmbeddingsRequest{
       Model: zhinao.ModelEmbeddingS1V1,
       Input: []string{"你好"},
    }

    resp, err := client.Embeddings.Create(ctx, basicReq)
    if err != nil {
       log.Printf("Error: %v\n", err)
    } else {
       fmt.Printf("✅ 模型: %s\n", resp.Model)
       fmt.Printf("📊 生成向量数: %d\n", len(resp.Data))
       fmt.Printf("📏 向量维度: %d\n", len(resp.Data[0].Embedding))
       fmt.Printf("🔢 Token 消耗: %d (总计: %d)\n", resp.Usage.PromptTokens, resp.Usage.TotalTokens)
       fmt.Printf("🎯 向量前5维: %.6f, %.6f, %.6f, %.6f, %.6f\n",
          resp.Data[0].Embedding[0],
          resp.Data[0].Embedding[1],
          resp.Data[0].Embedding[2],
          resp.Data[0].Embedding[3],
          resp.Data[0].Embedding[4])
       fmt.Println()
    }

    // 示例 2: 批量生成向量
    fmt.Println("2. 批量生成向量")
    batchReq := &zhinao.EmbeddingsRequest{
       Model: zhinao.ModelEmbeddingS1V1,
       Input: []string{
          "你好，世界",
          "人工智能",
          "自然语言处理",
       },
    }

    resp, err = client.Embeddings.Create(ctx, batchReq)
    if err != nil {
       log.Printf("Error: %v\n", err)
    } else {
       fmt.Printf("✅ 模型: %s\n", resp.Model)
       fmt.Printf("📊 生成向量数: %d\n", len(resp.Data))
       fmt.Printf("🔢 Token 消耗: %d (总计: %d)\n", resp.Usage.PromptTokens, resp.Usage.TotalTokens)
       for i, data := range resp.Data {
          fmt.Printf("  向量 %d: 维度=%d, 索引=%d\n", i+1, len(data.Embedding), data.Index)
       }
       fmt.Println()
    }

    // 示例 3: 使用 Builder 构建请求
    fmt.Println("3. 使用 Builder 构建请求")
    builderReq := zhinao.NewEmbeddings(zhinao.ModelEmbeddingS1V1).
       AddInput("机器学习").
       AddInput("深度学习").
       AddInput("神经网络").
       SetUser("example-user").
       Build()

    resp, err = client.Embeddings.Create(ctx, builderReq)
    if err != nil {
       log.Printf("Error: %v\n", err)
    } else {
       fmt.Printf("✅ 模型: %s\n", resp.Model)
       fmt.Printf("📊 生成向量数: %d\n", len(resp.Data))
       fmt.Printf("🔢 Token 消耗: %d\n", resp.Usage.TotalTokens)
       fmt.Println()
    }

    fmt.Println("=== 示例完成 ===")
    fmt.Println("💡 提示:")
    fmt.Println("   - 向量可用于语义搜索、文本分类、聚类等任务")
    fmt.Println("   - 批量生成向量可以提高效率")
    fmt.Println("   - 向量相似度计算建议使用专业向量数据库")
}

相关参考链接

• GitHub 仓库 : github.com/lin-coco/zh...
• 使用指南 : GUIDE.md
• 360智脑API文档 : ai.360.com/platform/do...