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

砖业林coco2025-11-05 11:28

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

项目简介

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

核心特性：

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

支持功能：

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

安装使用

bash 复制代码 
# 安装
go get github.com/lin-coco/zhinao-go

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

示例展示

1. 基础聊天补全

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

go 复制代码 
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. 交互式聊天机器人

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

go 复制代码 
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 响应，适合需要即时反馈的场景。

go 复制代码 
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 能够调用外部函数来获取信息或执行操作。

go 复制代码 
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 使用体验。

go 复制代码 
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. 模型列表

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

go 复制代码 
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. 文本生成图像

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

go 复制代码 
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）

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

go 复制代码 
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("   - 向量相似度计算建议使用专业向量数据库")
}

相关参考链接

相关推荐
山顶夕景21 小时前
【LLM】多模态智能体Kimi-K2.5模型
llm·agent·多模态
JTnnnnn21 小时前
【架構優化】拒絕 LLM 幻覺：設計基於 Python 路由的 AntV 智慧圖表生成系統
llm·antv·dify
AndrewHZ1 天前
【AI黑话日日新】什么是skills？
语言模型·大模型·llm·claude code·skills
asaotomo1 天前
一款 AI 驱动的新一代安全运维代理 —— DeepSentry（深哨）
运维·人工智能·安全·ai·go
国家一级假勤奋大学生1 天前
InternVL系列 technical report 解析
大模型·llm·vlm·mllm·internvl·调研笔记
码界奇点2 天前
基于Gin与GORM的若依后台管理系统设计与实现
论文阅读·go·毕业设计·gin·源代码管理
缘友一世2 天前
张量并行和流水线并行原理深入理解与思考
学习·llm·pp·tp
迷迭香与樱花2 天前
Gin 框架
go·gin
CoderJia程序员甲2 天前
GitHub 热榜项目 - 日榜(2026-01-30)
开源·大模型·llm·github·ai教程
亚里随笔2 天前
MegaFlow：面向Agent时代的大规模分布式编排系统
人工智能·分布式·llm·rl·agentic
热门推荐
01GitHub 镜像站点02Clawdbot 中文汉化版 接入微信、飞书03OpenClaw部署与配置教程：在Mac mini上接入国产大模型与飞书042026美赛A题智能手机电池续航时间预测的连续时间数学模型05OpenCode 入门教程：介绍 · 安装 · 配置第三方 API (如 Claude)06Linux下V2Ray安装配置指南07UV安装并设置国内源08Claude Code + GLM4.7 避坑指南：解决 Unable to connect to Anthropic services092025 年大语言模型发展回顾：关键突破、意外转折与 2026 年展望10Claude Code Skills 实用使用手册