Go 快速开始

AI 快速开始

准备工作

在开始之前，请确保您已完成以下准备：

1. 开通云开发环境：开通云开发环境
2. 获取 API 访问凭证：在 CloudBase 控制台 获取环境 ID 和 API 密钥

Client

配置你的 AI 工具以连接 CloudBase 能力 支持本地与托管两种连接方式，详见 连接方式。

步骤 1：安装 / 配置 CloudBase

步骤 2：和 AI 对话

在 AI 对话中依次输入以下内容:

prompt

安装 CloudBase Skills：命令 npx skills add tencentcloudbase/cloudbase-skills -y

使用 CloudBase Skills： 使用 CloudBase Skills：在 Go 后端服务中集成 CloudBase，包括数据库和云存储

完整开发指引

准备工作

在开始之前，请确保您已完成以下准备：

1. 开通云开发环境：开通云开发环境
2. 获取 API 访问凭证：在 CloudBase 控制台 获取环境 ID 和 API 密钥

更多详情请参考：Go 完整文档

身份认证

package main

import "fmt"

func SignIn(username, password string) (map[string]interface{}, error) {
	result, err := Cloudbase.Request("POST", "/auth/v1/signin",
		map[string]interface{}{
			"username": username,
			"password": password,
		}, nil)

	if err != nil {
		return nil, err
	}

	if resultMap, ok := result.(map[string]interface{}); ok {
		accessToken := resultMap["access_token"].(string)
		userID := resultMap["sub"].(string)

		fmt.Printf("登录成功! 用户ID: %s\n", userID)
		fmt.Printf("访问令牌: %s...\n", accessToken[:20])
		return resultMap, nil
	}

	return nil, fmt.Errorf("登录失败")
}

// 使用示例
func main() {
	result, err := SignIn("your_username", "your_password")
	if err != nil {
		fmt.Println("错误:", err)
	}
}

云存储

上传文件

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"path/filepath"
	"time"
)

func UploadFile(filePath, objectID string) (map[string]interface{}, error) {
	if objectID == "" {
		filename := filepath.Base(filePath)
		timestamp := time.Now().UnixMilli()
		objectID = fmt.Sprintf("uploads/%d-%s", timestamp, filename)
	}

	uploadInfo, err := Cloudbase.Request("POST", "/v1/storages/get-objects-upload-info",
		[]map[string]interface{}{{"objectId": objectID}}, nil)

	if err != nil {
		return nil, err
	}

	infoList, ok := uploadInfo.([]interface{})
	if !ok || len(infoList) == 0 {
		return nil, fmt.Errorf("获取上传信息失败")
	}

	info := infoList[0].(map[string]interface{})
	uploadURL := info["uploadUrl"].(string)

	file, err := os.Open(filePath)
	if err != nil {
		return nil, fmt.Errorf("文件不存在: %s", filePath)
	}
	defer file.Close()

	fileData, err := io.ReadAll(file)
	if err != nil {
		return nil, fmt.Errorf("读取文件失败: %w", err)
	}

	req, err := http.NewRequest("PUT", uploadURL, bytes.NewReader(fileData))
	if err != nil {
		return nil, err
	}

	req.Header.Set("Authorization", info["authorization"].(string))
	req.Header.Set("X-Cos-Security-Token", info["token"].(string))
	req.Header.Set("X-Cos-Meta-Fileid", info["cloudObjectMeta"].(string))

	client := &http.Client{}
	resp, err := client.Do(req)
	if err != nil {
		return nil, fmt.Errorf("文件上传失败: %w", err)
	}
	defer resp.Body.Close()

	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return nil, fmt.Errorf("上传失败，状态码: %d", resp.StatusCode)
	}

	result := map[string]interface{}{
		"cloudObjectId": info["cloudObjectId"],
		"downloadUrl":   info["downloadUrl"],
		"objectId":      objectID,
	}

	fmt.Println("文件上传成功:")
	fmt.Printf("- 对象ID: %s\n", result["objectId"])
	fmt.Printf("- 下载URL: %s\n", result["downloadUrl"])

	return result, nil
}

// 使用示例
func main() {
	result, err := UploadFile("./example.jpg", "")
	if err != nil {
		fmt.Println("错误:", err)
	}
}

获取文件链接

package main

import "fmt"

func GetFileURL(cloudObjectID string) (string, error) {
	result, err := Cloudbase.Request("POST", "/v1/storages/get-objects-download-info",
		[]map[string]interface{}{{"cloudObjectId": cloudObjectID}}, nil)

	if err != nil {
		return "", err
	}

	if resultList, ok := result.([]interface{}); ok && len(resultList) > 0 {
		if info, ok := resultList[0].(map[string]interface{}); ok {
			if downloadURL, ok := info["downloadUrl"].(string); ok {
				fmt.Println("文件链接:", downloadURL)
				return downloadURL, nil
			}
		}
	}

	return "", fmt.Errorf("获取文件链接失败")
}

// 使用示例
func main() {
	fileURL, err := GetFileURL("cloud://xxx.png")
	if err != nil {
		fmt.Println("错误:", err)
	}
}

下载文件

package main

import (
	"fmt"
	"io"
	"net/http"
	"os"
	"path/filepath"
	"strings"
)

func DownloadFile(cloudObjectID, savePath string) (bool, error) {
	if savePath == "" {
		savePath = "./"
	}

	result, err := Cloudbase.Request("POST", "/v1/storages/get-objects-download-info",
		[]map[string]interface{}{{"cloudObjectId": cloudObjectID}}, nil)

	if err != nil {
		return false, err
	}

	if resultList, ok := result.([]interface{}); ok && len(resultList) > 0 {
		if info, ok := resultList[0].(map[string]interface{}); ok {
			downloadURL := info["downloadUrl"].(string)

			parts := strings.Split(downloadURL, "/")
			filename := strings.Split(parts[len(parts)-1], "?")[0]

			fileInfo, err := os.Stat(savePath)
			var fullPath string
			if err == nil && fileInfo.IsDir() || strings.HasSuffix(savePath, "/") {
				fullPath = filepath.Join(savePath, filename)
			} else {
				fullPath = savePath
			}

			resp, err := http.Get(downloadURL)
			if err != nil {
				return false, fmt.Errorf("下载失败: %w", err)
			}
			defer resp.Body.Close()

			if resp.StatusCode < 200 || resp.StatusCode >= 300 {
				return false, fmt.Errorf("下载失败，状态码: %d", resp.StatusCode)
			}

			outFile, err := os.Create(fullPath)
			if err != nil {
				return false, err
			}
			defer outFile.Close()

			_, err = io.Copy(outFile, resp.Body)
			if err != nil {
				return false, err
			}

			fmt.Printf("下载成功! 文件已保存到: %s\n", fullPath)
			return true, nil
		}
	}

	return false, fmt.Errorf("下载失败")
}

// 使用示例
func main() {
	// 下载到当前目录，使用原文件名
	success, err := DownloadFile("cloud://xxx.png", "")

	// 下载到指定目录
	// success, err := DownloadFile("cloud://xxx.png", "./downloads/")

	// 下载并重命名
	// success, err := DownloadFile("cloud://xxx.png", "./my-image.png")

	if err != nil {
		fmt.Println("错误:", err)
	}
}

删除文件

package main

import "fmt"

func DeleteFile(cloudObjectIDs interface{}) (bool, error) {
	var data []map[string]interface{}

	switch v := cloudObjectIDs.(type) {
	case string:
		data = []map[string]interface{}{{"cloudObjectId": v}}
	case []string:
		for _, id := range v {
			data = append(data, map[string]interface{}{"cloudObjectId": id})
		}
	default:
		return false, fmt.Errorf("不支持的参数类型")
	}

	_, err := Cloudbase.Request("POST", "/v1/storages/delete-objects", data, nil)
	if err != nil {
		return false, err
	}

	fmt.Println("删除成功!")
	return true, nil
}

// 使用示例
func main() {
	success, err := DeleteFile("cloud://xxx.png")
	if err != nil {
		fmt.Println("错误:", err)
	}
}

云函数

package main

import "fmt"

func CallFunction(functionName string, data map[string]interface{}) (interface{}, error) {
	if data == nil {
		data = map[string]interface{}{}
	}

	path := fmt.Sprintf("/v1/functions/%s", functionName)
	result, err := Cloudbase.Request("POST", path, data, nil)

	if err != nil {
		return nil, err
	}

	fmt.Println("云函数调用结果:", result)
	return result, nil
}

// 使用示例
func main() {
	result, err := CallFunction("{%FUNCTION_NAME%}", nil)
	if err != nil {
		fmt.Println("错误:", err)
	}
}

大模型

生文模型

package main

import (
	"bufio"
	"bytes"
	"encoding/json"
	"fmt"
	"net/http"
	"strings"
)

func StreamText(model, subModel string, messages []map[string]string) (string, error) {
	payload := map[string]interface{}{
		"model":    subModel,
		"messages": messages,
		"stream":   true,
	}

	jsonData, err := json.Marshal(payload)
	if err != nil {
		return "", err
	}

	url := fmt.Sprintf("%s/v1/ai/%s/chat/completions", Cloudbase.BaseURL, model)
	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
	if err != nil {
		return "", err
	}

	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Accept", "text/event-stream")
	req.Header.Set("Authorization", "Bearer "+Cloudbase.AccessToken)

	resp, err := Cloudbase.HTTPClient.Do(req)
	if err != nil {
		return "", fmt.Errorf("AI 调用失败: %w", err)
	}
	defer resp.Body.Close()

	fmt.Println("AI 流式响应:")
	fullContent := ""
	scanner := bufio.NewScanner(resp.Body)

	for scanner.Scan() {
		line := scanner.Text()
		if strings.HasPrefix(line, "data: ") {
			dataStr := strings.TrimPrefix(line, "data: ")
			if strings.TrimSpace(dataStr) != "[DONE]" {
				var chunkData map[string]interface{}
				if err := json.Unmarshal([]byte(dataStr), &chunkData); err == nil {
					if choices, ok := chunkData["choices"].([]interface{}); ok && len(choices) > 0 {
						if choice, ok := choices[0].(map[string]interface{}); ok {
							if delta, ok := choice["delta"].(map[string]interface{}); ok {
								if content, ok := delta["content"].(string); ok {
									fmt.Print(content)
									fullContent += content
								}
							}
						}
					}
				}
			}
		}
	}

	fmt.Println()
	return fullContent, nil
}

// 使用示例
func main() {
	response, err := StreamText(
		"{%AI_MODEL_NAME%}",
		"{%AI_SUB_MODEL_NAME%}",
		[]map[string]string{
			{"role": "system", "content": "请严格按照七言绝句或七言律诗的格律要求创作，平仄需符合规则，押韵要和谐自然，韵脚字需在同一韵部。"},
			{"role": "user", "content": "春天"},
		},
	)
	if err != nil {
		fmt.Println("错误:", err)
	}
}

生图模型

生图模型通过调用云函数来实现，在生图模型页面点击「一键创建云函数」，函数调用示例如下：

package main

import "fmt"

func GenerateImage(prompt string) (map[string]interface{}, error) {
	// 准备调用参数
	data := map[string]interface{}{
		"prompt": prompt,
	}

	// 调用云函数生成图片
	result, err := Cloudbase.Request("POST", "/v1/functions/<YOUR_FUNCTION_NAME>", data, nil)
	if err != nil {
		return nil, err
	}

	if resultMap, ok := result.(map[string]interface{}); ok {
		if success, ok := resultMap["success"].(bool); ok && success {
			imageUrl := resultMap["imageUrl"].(string)
			revisedPrompt := ""
			if rp, ok := resultMap["revised_prompt"].(string); ok {
				revisedPrompt = rp
			}

			fmt.Println("生成成功!")
			fmt.Printf("图片URL: %s\n", imageUrl)
			fmt.Printf("优化后的提示词: %s\n", revisedPrompt)
			fmt.Println("注意: 图片URL有效期为24小时")

			return resultMap, nil
		} else {
			code := ""
			message := ""
			if c, ok := resultMap["code"].(string); ok {
				code = c
			}
			if m, ok := resultMap["message"].(string); ok {
				message = m
			}
			return nil, fmt.Errorf("生成失败: %s - %s", code, message)
		}
	}

	return nil, fmt.Errorf("请求失败")
}

// 使用示例
func main() {
	result, err := GenerateImage("一只可爱的猫咪在阳光下玩耍")
	if err != nil {
		fmt.Println("错误:", err)
	} else {
		fmt.Println("图片生成完成:", result)
	}
}