Go 使用示例--大模型应用防火墙-火山引擎

文档中心

立即注册

大模型应用防火墙

Go SDK

Go 使用示例

本文为您提供大模型应用防火墙接口调用的示例代码。实际使用时，您可以替换成 SDK 中已经支持的任意接口。

前提条件

您已经在控制台配置相关防护策略，策略配置详情请参见防护策略介绍。
您已经完成Go 安装和初始化。

使用限制

您在使用大模型应用防火墙 SDK 调用 API 之前，请务必了解 API 使用限制，详情请参见使用限制。

关键参数说明

参考以下表格了解 SDK 中的关键参数说明及获取方法。

参数	示例值	说明
myUrl	实例所在区域为北京：`https://cn-beijing.sdk.access.llm-shield.omini-shield.com` 实例所在区域为上海：`https://cn-shanghai.sdk.access.llm-shield.omini-shield.com`	参数说明：大模型应用防火墙对外提供的接口服务地址，形如`https://{region}.sdk.access.llm-shield.omini-shield.com`，其中 region 为您购买的实例所属地域。华北2（北京）：cn-beijing 华东2（上海）：cn-shanghai 获取方式：可前往大模型应用防火墙控制台实例管理模块，查看实例所在区域。
ak、sk	AK：AKLTYWRhNDMw** SK：TWprNE5XVXlZbc**	参数说明：火山引擎账号的 Access Key ID 和 Secret Access Key。获取方式：获取说明请参见 Access Key（密钥）管理。
appid	app-d35p9du8pa51****	参数说明：资产的唯一标识，完成控制台接入配置后，系统将自动生成 AppID。注意 SDK 调用时支持传入通过 SDK 方式接入的资产 AppID，其他接入方式的资产不生效。获取方式：可前往大模型应用防火墙控制台资产管理模块，查看已通过 SDK 方式接入的资产 AppID。
region	实例所在区域为北京：cn-beijing 实例所在区域为上海：cn-shanghai	参数说明：大模型应用防火墙实例所属地域，与 myUrl 中的 region 保持一致。华北2（北京）：cn-beijing 华东2（上海）：cn-shanghai 获取方式：可前往大模型应用防火墙控制台实例管理模块，查看实例所在区域。

文本检测

检测输入或输出内容是否合规（非流式）

适用场景：非流式检测适用于需要完整上下文的深度语义分析场景，在一次调用中完成全部消息内容检测。
接口说明：详细接口说明请参见检测输入或输出内容是否合规。

无代理服务

有代理服务

package main

import (
        "fmt"
        "github.com/volcengine/volcengine-go-sdk/service/llmshield"
        "time"
)

func main() {
    var response *llmshield.ModerateV2Response
    var err error

        myUrl := "https://cn-beijing.sdk.access.llm-shield.omini-shield.com" // 根据大模型应用防火墙实例所在地域替换相应的地域信息
        ak := "YOUR AK" // 火山账号的 AK
        sk := "YOUR SK" // 火山账号的 SK
        appid := "app-d2vektrahgp6********" // 资产的 AppId，可在控制台获取
        region := "cn-beijing" // 大模型应用防火墙实例所在地域

        timeout := time.Second * 60 // 超时时间
        client := llmshield.New(myUrl, ak, sk, region, timeout) // 创建客户端实例
        request := llmshield.ModerateV2Request{
                Message: nil,
                Scene:   appid, // 资产的 AppId
        }
        // 设置检测内容
        request.Message = &llmshield.MessageV2{
                Content:     "网上都说A地很多骗子和小偷，他们的典型伎俩...",
                ContentType: llmshield.ContentTypeV2_TEXT,
                Role:        "user",  // 检测的内容来源，user-用户提示词；assistant-模型响应内容
        }
        // 设置上下文
        request.History = append(request.History, &llmshield.MessageV2{
                Content:     "你是一个专业的问答助手，你的任务是回答用户的问题，注意保持友善和专业。",
                ContentType: llmshield.ContentTypeV2_TEXT,
                Role:        "system",  // 上下文内容来源，user-用户提示词；assistant-模型响应内容；system-系统默认提示词
        })
        // 设置上下文
        request.History = append(request.History, &llmshield.MessageV2{
                Content:     "请给我一份十一出行计划",
                ContentType: llmshield.ContentTypeV2_TEXT,
                Role:        "user",  // 上下文内容来源，user-用户提示词；assistant-模型响应内容；system-系统默认提示词
        })

        if client == nil {
                fmt.Printf("Failed to create client instance
")
                return
        }
        response, err = client.Moderate(&request)
        if err != nil {
                fmt.Printf("Error occurred while checking LLM response stream: %v
", err)
        }
        if response == nil {
                fmt.Println("Received empty result")
        }
        fmt.Printf("Received result: %s
", response.String())

}

package main

import (
        "fmt"
        "github.com/volcengine/volcengine-go-sdk/service/llmshield"
        "time"
)

func main() {
    var response *llmshield.ModerateV2Response
    var err error

        myUrl := "https://cn-beijing.sdk.access.llm-shield.omini-shield.com" // 根据大模型应用防火墙实例所在地域替换相应的地域信息
        ak := "YOUR AK" // 火山账号的 AK
        sk := "YOUR SK" // 火山账号的 SK
        appid := "app-d2vektrahgp6********" // 资产的 AppId，可在控制台获取
        region := "cn-beijing" // 大模型应用防火墙实例所在地域

        timeout := time.Second * 60 // 超时时间
        client := llmshield.NewAdvanced(myUrl, ak, sk, region, timeout, "http://10.37.**.**:8888", 30) // 初始化大模型应用防火墙客户端，其中 "http://10.37.**.**:8888" 为代理地址示例值、30 为最大连接数示例值
        request := llmshield.ModerateV2Request{
                Message: nil,
                Scene:   appid, // 资产的 AppId
        }
        // 设置检测内容
        request.Message = &llmshield.MessageV2{
                Content:     "网上都说A地很多骗子和小偷，他们的典型伎俩...",
                ContentType: llmshield.ContentTypeV2_TEXT,
                Role:        "user",  // 检测的内容来源，user-用户提示词；assistant-模型响应内容
        }
        // 设置上下文
        request.History = append(request.History, &llmshield.MessageV2{
                Content:     "你是一个专业的问答助手，你的任务是回答用户的问题，注意保持友善和专业。",
                ContentType: llmshield.ContentTypeV2_TEXT,
                Role:        "system",  // 上下文内容来源，user-用户提示词；assistant-模型响应内容；system-系统默认提示词
        })
        // 设置上下文
        request.History = append(request.History, &llmshield.MessageV2{
                Content:     "请给我一份十一出行计划",
                ContentType: llmshield.ContentTypeV2_TEXT,
                Role:        "user",  // 上下文内容来源，user-用户提示词；assistant-模型响应内容；system-系统默认提示词
        })

        if client == nil {
                fmt.Printf("Failed to create client instance
")
                return
        }
        response, err = client.Moderate(&request)
        if err != nil {
                fmt.Printf("Error occurred while checking LLM response stream: %v
", err)
        }
        if response == nil {
                fmt.Println("Received empty result")
        }
        fmt.Printf("Received result: %s
", response.String())

}

检测输入或输出内容是否合规（流式）

适用场景：流式检测适用于大模型流式响应处理场景，通过分段传输实现高效校验。无需等待完整响应内容生成即可开始检测，显著降低整体响应延迟。
参数配置：
- 需要在一次流式审核中始终传入一个 session 实例，用于关联一个响应流的上下文。
- 在调用时设置UseStream = 1，多次发送分块内容。
- 最后一次输入时，需设置UseStream = 2，帮助 SDK 释放资源。
接口说明：详细接口说明请参见检测输入或输出内容是否合规。

无代理服务

有代理服务

package main

import (
    "encoding/json"
    "fmt"
    "github.com/volcengine/volcengine-go-sdk/service/llmshield"
    "time"
)

func main() {
    //请输入您想要校验的文本，这里是一个示例，您可以根据您的需求传入任意长度的字符串，用来模拟您的输入流
    longText := "这是一种非常严重的违法行为，被称为“网络钓鱼”或“社交工程攻击”。这种行为涉及通过电子邮件、短信或其他形式的通信来骗取个人敏感信息（如姓名、地址、出生日期、信用卡号码等）。这些信息可以用于盗取受害者的财产或者身份。
 以下是一些常见的网络钓鱼行为：
 1. 通过虚假网站诱骗受害者输入个人信息。一个看起来像是银行网站的链接可能会要求您提供您的账户和密码等信息以验证您的身份。 通过发送带有恶意软件的附件或链接来获取个人信息。这通常发生在电子邮件中，当用户点击链接时，他们的计算机会被感染病毒，从而泄露了他们所有的个人信息。 利用社交媒体平台上的漏洞，向公众展示虚假的信息，以便获得人们的信任并诱导他们透露个人信息。
 要防止遭受网络钓鱼的攻击，您可以采取以下措施：
 1. 不要随意打开未知来源的邮件或消息； 在访问任何网站之前，请确保该网站是可信的和合法的； 避免在公共网络上使用不安全的Wi-Fi连接； 使用强而独特的密码，并在不同的网站上使用不同的密码； 安装杀毒软件和其他安全程序以防止病毒感染。"
    var response *llmshield.ModerateV2Response
    var err error
    myUrl := "https://cn-beijing.sdk.access.llm-shield.omini-shield.com/" // 根据大模型应用防火墙实例所在地域替换相应的地域信息
    ak := "YOUR AK"              // 火山账号的 AK
    sk := "YOUR SK"              // 火山账号的 SK
    appid := "app-d2pgblcjslsilvcv****"                   // 资产的 AppId，可在控制台获取
    region := "cn-beijing"        // 大模型应用防火墙实例所在地域
        timeout := time.Second * 30 // 超时时间
        // 创建客户端实例
        client := llmshield.New(myUrl, ak, sk, region, timeout)
        request := llmshield.ModerateV2Request{
                Message:   nil,
                Scene:     appid, // 资产的 AppId
                UseStream: 1,
        }
        // 定义请求结构体
        request.Message = &llmshield.MessageV2{
                Content:     "",
                ContentType: llmshield.ContentTypeV2_TEXT,
                Role:        "assistant",
        }
        // 添加历史用户提问
        request.History = append(request.History, &llmshield.MessageV2{
                Content:     "请给我一份十一出行计划",
                ContentType: llmshield.ContentTypeV2_TEXT,
                Role:        "user", // 检测的内容来源，user-用户提示词；assistant-模型响应内容
        })
        // 添加提示词
        request.History = append(request.History, &llmshield.MessageV2{
                Content:     "你是一个智能助手",
                ContentType: llmshield.ContentTypeV2_TEXT,
                Role:        "system", // 上下文内容来源，user-用户提示词；assistant-模型响应内容；system-系统默认提示词
        })
        // 添加助手回复
        request.History = append(request.History, &llmshield.MessageV2{
                Content:     "你是一个智能助手",
                ContentType: llmshield.ContentTypeV2_TEXT,
                Role:        "assistant", // 上下文内容来源，user-用户提示词；assistant-模型响应内容；system-系统默认提示词
        })

        if client == nil {
                fmt.Printf("Failed to create client instance
")
                return
        }
        session := llmshield.ModerateV2StreamSession{}
        // 这里模拟流式调用，每次传入长度为9， 您可以替换成您的实现，传入任意长度的内容
        chunkSize := 9
        textLength := len(longText)
        for i := 0; i < textLength; i += chunkSize {
                end := i + chunkSize
                if end >= textLength {
                        end = textLength
                        request.UseStream = 2
                }
                chunk := []byte(longText[i:end])
                request.Message.Content = string(chunk)
                /* 您可以多次流式的调用接口 ，接口会实时返回给您一个当前校验结果 */
                response, err = client.ModerateStream(&request, &session)
                if err != nil {
                        fmt.Printf("Error occurred while ModerateStream LLM response stream: %v
", err)
                        continue
                }

                if response == nil {
                        fmt.Println("Received empty result")
                        continue
                }

                tempString, err := json.MarshalIndent(response, "", "  ")
                if err != nil {
                        fmt.Printf("Failed to marshal response to JSON: %v
", err)
                        continue
                }

                fmt.Printf("Received result: %s
", string(tempString))
        }
}

package main

import (
    "encoding/json"
    "fmt"
    "github.com/volcengine/volcengine-go-sdk/service/llmshield"
    "time"
)

func main() {
    //请输入您想要校验的文本，这里是一个示例，您可以根据您的需求传入任意长度的字符串，用来模拟您的输入流
    longText := "这是一种非常严重的违法行为，被称为“网络钓鱼”或“社交工程攻击”。这种行为涉及通过电子邮件、短信或其他形式的通信来骗取个人敏感信息（如姓名、地址、出生日期、信用卡号码等）。这些信息可以用于盗取受害者的财产或者身份。
 以下是一些常见的网络钓鱼行为：
 1. 通过虚假网站诱骗受害者输入个人信息。一个看起来像是银行网站的链接可能会要求您提供您的账户和密码等信息以验证您的身份。 通过发送带有恶意软件的附件或链接来获取个人信息。这通常发生在电子邮件中，当用户点击链接时，他们的计算机会被感染病毒，从而泄露了他们所有的个人信息。 利用社交媒体平台上的漏洞，向公众展示虚假的信息，以便获得人们的信任并诱导他们透露个人信息。
 要防止遭受网络钓鱼的攻击，您可以采取以下措施：
 1. 不要随意打开未知来源的邮件或消息； 在访问任何网站之前，请确保该网站是可信的和合法的； 避免在公共网络上使用不安全的Wi-Fi连接； 使用强而独特的密码，并在不同的网站上使用不同的密码； 安装杀毒软件和其他安全程序以防止病毒感染。"
    var response *llmshield.ModerateV2Response
    var err error
    myUrl := "https://cn-beijing.sdk.access.llm-shield.omini-shield.com/" // 根据大模型应用防火墙实例所在地域替换相应的地域信息
    ak := "YOUR AK"              // 火山账号的 AK
    sk := "YOUR SK"              // 火山账号的 SK
    appid := "app-d2pgblcjslsilvcv****"                   // 资产的 AppId，可在控制台获取
    region := "cn-beijing"        // 大模型应用防火墙实例所在地域
        timeout := time.Second * 30 // 超时时间
        // 创建客户端实例
        client := llmshield.NewAdvanced(myUrl, ak, sk, region, timeout, "http://10.37.**.**:8888", 30) // 其中 "http://10.37.**.**:8888" 为代理地址示例值、30 为最大连接数示例值
        request := llmshield.ModerateV2Request{
                Message:   nil,
                Scene:     appid, // 资产的 AppId
                UseStream: 1,
        }
        // 定义请求结构体
        request.Message = &llmshield.MessageV2{
                Content:     "",
                ContentType: llmshield.ContentTypeV2_TEXT,
                Role:        "assistant",
        }
        // 添加历史用户提问
        request.History = append(request.History, &llmshield.MessageV2{
                Content:     "请给我一份十一出行计划",
                ContentType: llmshield.ContentTypeV2_TEXT,
                Role:        "user", // 检测的内容来源，user-用户提示词；assistant-模型响应内容
        })
        // 添加提示词
        request.History = append(request.History, &llmshield.MessageV2{
                Content:     "你是一个智能助手",
                ContentType: llmshield.ContentTypeV2_TEXT,
                Role:        "system", // 上下文内容来源，user-用户提示词；assistant-模型响应内容；system-系统默认提示词
        })
        // 添加助手回复
        request.History = append(request.History, &llmshield.MessageV2{
                Content:     "你是一个智能助手",
                ContentType: llmshield.ContentTypeV2_TEXT,
                Role:        "assistant", // 上下文内容来源，user-用户提示词；assistant-模型响应内容；system-系统默认提示词
        })

        if client == nil {
                fmt.Printf("Failed to create client instance
")
                return
        }
        session := llmshield.ModerateV2StreamSession{}
        // 这里模拟流式调用，每次传入长度为9， 您可以替换成您的实现，传入任意长度的内容
        chunkSize := 9
        textLength := len(longText)
        for i := 0; i < textLength; i += chunkSize {
                end := i + chunkSize
                if end >= textLength {
                        end = textLength
                        request.UseStream = 2
                }
                chunk := []byte(longText[i:end])
                request.Message.Content = string(chunk)
                /* 您可以多次流式的调用接口 ，接口会实时返回给您一个当前校验结果 */
                response, err = client.ModerateStream(&request, &session)
                if err != nil {
                        fmt.Printf("Error occurred while ModerateStream LLM response stream: %v
", err)
                        continue
                }

                if response == nil {
                        fmt.Println("Received empty result")
                        continue
                }

                tempString, err := json.MarshalIndent(response, "", "  ")
                if err != nil {
                        fmt.Printf("Failed to marshal response to JSON: %v
", err)
                        continue
                }

                fmt.Printf("Received result: %s
", string(tempString))
        }
}

上述代码中流式内容检测的实现逻辑如下流程图所示：

图片检测

适用场景：对图片内容进行检测以规避血腥、暴力、黄色等不良内容，保障内容的合规性与安全性，防止模型被滥用。
接口说明：详细接口说明请参见检测输入或输出内容是否合规。

无代理服务

有代理服务

package main

import (
    "encoding/base64"
    "fmt"
    "os"
    "time"
    "github.com/volcengine/volcengine-go-sdk/service/llmshield"
)

func EncodeImageToBase64(imagePath string) (string, error) {
    // 读取图片文件内容
    data, err := os.ReadFile(imagePath)
    if err != nil {
        return "", fmt.Errorf("读取图片失败: %v", err)
    }

    // 进行Base64编码
    base64Str := base64.StdEncoding.EncodeToString(data)
    return base64Str, nil
}

func main() {
    var response *llmshield.ModerateV2Response
    var err error
    myUrl := "https://cn-beijing.sdk.access-test.llm-shield.omini-shield.com" // 根据大模型应用防火墙实例所在地域替换相应的地域信息
    ak := "YOUR AK"  // 火山账号的 AK
    sk := "YOUR SK"  // 火山账号的 SK
    appid := "app-d3r06khsqn9s73da****" // 资产的 AppId，可在控制台资产管理页面获取
    region := "cn-beijing" // 大模型应用防火墙实例所在地域

    timeout := time.Second * 60 // 超时时间
    request := llmshield.ModerateV2Request{
        Message: nil,
        Scene:   appid,
    }

    dtstr, err := EncodeImageToBase64("/Users/Downloads/192750.jpeg") // 待检测图片的本地存储路径
    dsize := len(dtstr)
    // 确保图片大小不超过 10 MB
    if err != nil || dsize > 10*1024*1024 {
        fmt.Printf("%v,dsize:%v", err, dsize)
        return
    }
    request.Message = &llmshield.MessageV2{
        Content:     dtstr,
        ContentType: llmshield.ContentTypeV2_IMAGE,
        Role:        "user",
    }

    // 创建客户端实例
    client := llmshield.New(myUrl, ak, sk, region, timeout)
    if client == nil {
        fmt.Printf("Failed to create client instance
")
        return
    }
    response, err = client.Moderate(&request)
    if err != nil {
        fmt.Printf("Error occurred while checking LLM response stream: %v
", err)
    }
    if response == nil {
        fmt.Println("Received empty result")
    }
    fmt.Printf("Received result: %s
", response.String())
}

package main

import (
    "encoding/base64"
    "fmt"
    "os"
    "time"
    "github.com/volcengine/volcengine-go-sdk/service/llmshield"
)

func EncodeImageToBase64(imagePath string) (string, error) {
    // 读取图片文件内容
    data, err := os.ReadFile(imagePath)
    if err != nil {
        return "", fmt.Errorf("读取图片失败: %v", err)
    }

    // 进行Base64编码
    base64Str := base64.StdEncoding.EncodeToString(data)
    return base64Str, nil
}

func main() {
    var response *llmshield.ModerateV2Response
    var err error
    myUrl := "https://cn-beijing.sdk.access-test.llm-shield.omini-shield.com" // 根据大模型应用防火墙实例所在地域替换相应的地域信息
    ak := "YOUR AK"  // 火山账号的 AK
    sk := "YOUR SK"  // 火山账号的 SK
    appid := "app-d3r06khsqn9s73da****" // 资产的 AppId，可在控制台资产管理页面获取
    region := "cn-beijing" // 大模型应用防火墙实例所在地域

    timeout := time.Second * 60 // 超时时间
    request := llmshield.ModerateV2Request{
        Message: nil,
        Scene:   appid,
    }

    dtstr, err := EncodeImageToBase64("/Users/Downloads/192750.jpeg") // 待检测图片的本地存储路径
    dsize := len(dtstr)
    // 确保图片大小不超过 10 MB
    if err != nil || dsize > 10*1024*1024 {
        fmt.Printf("%v,dsize:%v", err, dsize)
        return
    }
    request.Message = &llmshield.MessageV2{
        Content:     dtstr,
        ContentType: llmshield.ContentTypeV2_IMAGE,
        Role:        "user",
    }

    // 创建客户端实例
    client := llmshield.NewAdvanced(myUrl, ak, sk, region, timeout, "http://10.37.**.**:8888", 30) // 其中 "http://10.37.**.**:8888" 为代理地址示例值、30 为最大连接数示例值
    if client == nil {
        fmt.Printf("Failed to create client instance
")
        return
    }
    response, err = client.Moderate(&request)
    if err != nil {
        fmt.Printf("Error occurred while checking LLM response stream: %v
", err)
    }
    if response == nil {
        fmt.Println("Received empty result")
    }
    fmt.Printf("Received result: %s
", response.String())
}

文档检测

适用场景：对文档内容进行检测以规避血腥、暴力、黄色等不良内容，保障内容的合规性与安全性，防止模型被滥用。
接口说明：详细接口说明请参检测输入或输出内容是否合规。

无代理服务

有代理服务

package main

import (
    "encoding/base64"
    "fmt"
    "os"
    "time"

    "github.com/volcengine/volcengine-go-sdk/service/llmshield"
)

func encodeFileToBase64(ftype string, filePath string) (string, error) {
    data, err := os.ReadFile(filePath)
    if err != nil {
        return "", fmt.Errorf("读取文件失败: %v", err)
    }

    base64Str := base64.StdEncoding.EncodeToString(data)
    switch ftype {
    case "doc":
        base64Str = "data:application/msword;base64," + base64Str
    case "docx":
        base64Str = "data:application/vnd.openxmlformats-officedocument.wordprocessingml.document;base64," + base64Str
    case "txt":
        base64Str = "data:text/plain;base64," + base64Str
    case "xls":
        base64Str = "data:application/vnd.ms-excel;base64," + base64Str
    case "xlsx":
        base64Str = "data:application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;base64," + base64Str
    case "pdf":
        base64Str = "data:application/pdf;base64," + base64Str
    }

    return base64Str, nil
}

func FilledMsgFile(ftype string, ctype llmshield.ContentTypeV2, fileName string) *llmshield.MultiPart {
    dtstr, err := encodeFileToBase64(ftype, fileName)
    if err != nil {
        fmt.Printf("FilledMsgFile error: %v", err)
        return nil
    }

    msg_multi := &llmshield.MultiPart{
        Content:     dtstr,
        ContentType: ctype,
    }

    return msg_multi
}

func main() {
    var response *llmshield.ModerateV2Response
    var err error
    myUrl := "https://cn-beijing.sdk.access-test.llm-shield.omini-shield.com" // 根据大模型应用防火墙实例所在地域替换相应的地域信息
    ak := "YOUR AK"  // 火山账号的 AK
    sk := "YOUR SK"  // 火山账号的 SK
    appid := "app-d3r06khsqn9s73da****" // 资产的 AppId，可在控制台资产管理页面获取
    region := "cn-beijing" // 大模型应用防火墙实例所在地域

    timeout := time.Second * 60 // 超时时间
    request := llmshield.ModerateV2Request{
        Message: nil,
        Scene:   appid,
    }

    dtstr, _ := encodeFileToBase64("docx", "/Users/example/demo.docx") // 待检测文档的本地存储路径
    request.Message = &llmshield.MessageV2{
        Content:     dtstr,
        ContentType: llmshield.ContentTypeV2_FILE,
        Role:        "user",
    }

    // 创建客户端实例
    client := llmshield.New(myUrl, ak, sk, region, timeout)
    if client == nil {
        fmt.Printf("Failed to create client instance
")
        return
    }
    response, err = client.Moderate(&request)
    if err != nil {
        fmt.Printf("Error occurred while checking LLM response stream: %v
", err)
    }
    if response == nil {
        fmt.Println("Received empty result")
    }
    fmt.Printf("Received result: %s
", response.String())
}

package main

import (
    "encoding/base64"
    "fmt"
    "os"
    "time"

    "github.com/volcengine/volcengine-go-sdk/service/llmshield"
)

func encodeFileToBase64(ftype string, filePath string) (string, error) {
    data, err := os.ReadFile(filePath)
    if err != nil {
        return "", fmt.Errorf("读取文件失败: %v", err)
    }

    base64Str := base64.StdEncoding.EncodeToString(data)
    switch ftype {
    case "doc":
        base64Str = "data:application/msword;base64," + base64Str
    case "docx":
        base64Str = "data:application/vnd.openxmlformats-officedocument.wordprocessingml.document;base64," + base64Str
    case "txt":
        base64Str = "data:text/plain;base64," + base64Str
    case "xls":
        base64Str = "data:application/vnd.ms-excel;base64," + base64Str
    case "xlsx":
        base64Str = "data:application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;base64," + base64Str
    case "pdf":
        base64Str = "data:application/pdf;base64," + base64Str
    }

    return base64Str, nil
}

func FilledMsgFile(ftype string, ctype llmshield.ContentTypeV2, fileName string) *llmshield.MultiPart {
    dtstr, err := encodeFileToBase64(ftype, fileName)
    if err != nil {
        fmt.Printf("FilledMsgFile error: %v", err)
        return nil
    }

    msg_multi := &llmshield.MultiPart{
        Content:     dtstr,
        ContentType: ctype,
    }

    return msg_multi
}

func main() {
    var response *llmshield.ModerateV2Response
    var err error
    myUrl := "https://cn-beijing.sdk.access-test.llm-shield.omini-shield.com" // 根据大模型应用防火墙实例所在地域替换相应的地域信息
    ak := "YOUR AK"  // 火山账号的 AK
    sk := "YOUR SK"  // 火山账号的 SK
    appid := "app-d3r06khsqn9s73da****" // 资产的 AppId，可在控制台资产管理页面获取
    region := "cn-beijing" // 大模型应用防火墙实例所在地域

    timeout := time.Second * 60 // 超时时间
    request := llmshield.ModerateV2Request{
        Message: nil,
        Scene:   appid,
    }

    dtstr, _ := encodeFileToBase64("docx", "/Users/example/demo.docx") // 待检测文档的本地存储路径
    request.Message = &llmshield.MessageV2{
        Content:     dtstr,
        ContentType: llmshield.ContentTypeV2_FILE,
        Role:        "user",
    }

    // 创建客户端实例
    client := llmshield.NewAdvanced(myUrl, ak, sk, region, timeout, "http://10.37.**.**:8888", 30) // 其中 "http://10.37.**.**:8888" 为代理地址示例值、30 为最大连接数示例值
    if client == nil {
        fmt.Printf("Failed to create client instance
")
        return
    }
    response, err = client.Moderate(&request)
    if err != nil {
        fmt.Printf("Error occurred while checking LLM response stream: %v
", err)
    }
    if response == nil {
        fmt.Println("Received empty result")
    }
    fmt.Printf("Received result: %s
", response.String())
}

多模态混合检测

适用场景：同时对文本、图片或文档进行混合检测，以规避血腥、暴力、黄色等不良内容，保障内容的合规性与安全性，防止模型被滥用。
接口说明：详细接口说明请参检测输入或输出内容是否合规。

无代理服务

有代理服务

package main

import (
        "encoding/base64"
        "fmt"
        "os"
        "time"

        "github.com/volcengine/volcengine-go-sdk/service/llmshield"
)

// 文档Base64编码
func encodeFileToBase64(ftype string, filePath string) (string, error) {
        // 读取文档内容
        data, err := os.ReadFile(filePath)
        if err != nil {
                return "", fmt.Errorf("读取文件失败: %v", err)
        }
        // 进行Base64编码
        base64Str := base64.StdEncoding.EncodeToString(data)
        switch ftype {
        case "doc":
                base64Str = "data:application/msword;base64," + base64Str
        case "docx":
                base64Str = "data:application/vnd.openxmlformats-officedocument.wordprocessingml.document;base64," + base64Str
        case "txt":
                base64Str = "data:text/plain;base64," + base64Str
        case "xls":
                base64Str = "data:application/vnd.ms-excel;base64," + base64Str
        case "xlsx":
                base64Str = "data:application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;base64," + base64Str
        case "pdf":
                base64Str = "data:application/pdf;base64," + base64Str
        }
        return base64Str, nil
}

// 检测文档函数，传入文档格式、文档检测类型、文档本地存储路径
func FilledMsgFile(ftype string, ctype llmshield.ContentTypeV2, fileName string) *llmshield.MultiPart {
        dtstr, err := encodeFileToBase64(ftype, fileName)
        if err != nil {
                fmt.Printf("FilledMsgFile error: %v", err)
                return nil
        }

        msg_multi := &llmshield.MultiPart{
                Content:     dtstr,
                ContentType: ctype,
        }

        return msg_multi
}

// 图片Base64编码
func EncodeImageToBase64(imagePath string) (string, error) {
        // 读取图片文件内容
        data, err := os.ReadFile(imagePath)
        if err != nil {
                return "", fmt.Errorf("读取图片失败: %v", err)
        }
        // 进行Base64编码
        base64Str := base64.StdEncoding.EncodeToString(data)
        return base64Str, nil
}

// 检测图片函数，传入图片检测类型、图片本地存储路径
func FilledMsgImage(ctype llmshield.ContentTypeV2, imagePath string) *llmshield.MultiPart {
        dtstr, err := EncodeImageToBase64(imagePath)
        if err != nil {
                fmt.Printf("FilledMsgImage error: %v", err)
                return nil
        }

        msg_multi := &llmshield.MultiPart{
                Content:     dtstr,
                ContentType: ctype,
        }

        return msg_multi
}

func main() {
        var response *llmshield.ModerateV2Response
        var err error
        myUrl := "https://cn-beijing.sdk.access-test.llm-shield.omini-shield.com" // 根据大模型应用防火墙实例所在地域替换相应的地域信息
        ak := "YOUR AK"  // 火山账号的 AK
        sk := "YOUR SK"  // 火山账号的 SK
        appid := "app-d3r06khsqn9s73da****" // 资产的 AppId，可在控制台资产管理页面获取
        region := "cn-beijing" // 大模型应用防火墙实例所在地域
        timeout := time.Second * 60 // 超时时间
        
        request := llmshield.ModerateV2Request{
                Message: nil,
                Scene:   appid,
        }

        // 创建客户端实例
        client := llmshield.New(myUrl, ak, sk, region, timeout)
        if client == nil {
                fmt.Printf("Failed to create client instance
")
                return
        }
        // 多模态混合检测文档
        part_file := FilledMsgFile("docx", llmshield.ContentTypeV2_FILE, "/Users/example/filedemo.docx")
        // 多模态混合检测图片
        part_image := FilledMsgImage(llmshield.ContentTypeV2_IMAGE, "/Users/example/imagedemo.png")
        // 多模态混合检测文本
        part_content := &llmshield.MultiPart{
                Content:     "网上都说A地很多骗子和小偷，他们的典型伎俩...", // 示例文本
                ContentType: llmshield.ContentTypeV2_TEXT,
        }
        
        request.Message = &llmshield.MessageV2{
                Role:      "user",
                MultiPart: []*llmshield.MultiPart{part_content, part_image, part_file},
        }

        response, err = client.Moderate(&request)
        if err != nil {
                fmt.Printf("Error occurred while checking LLM response stream: %v
", err)
        }
        if response == nil {
                fmt.Println("Received empty result")
        }
        fmt.Printf("Received result: %s
", response.String())
}

package main

import (
        "encoding/base64"
        "fmt"
        "os"
        "time"

        "github.com/volcengine/volcengine-go-sdk/service/llmshield"
)

// 文档Base64编码
func encodeFileToBase64(ftype string, filePath string) (string, error) {
        // 读取文档内容
        data, err := os.ReadFile(filePath)
        if err != nil {
                return "", fmt.Errorf("读取文件失败: %v", err)
        }
        // 进行Base64编码
        base64Str := base64.StdEncoding.EncodeToString(data)
        switch ftype {
        case "doc":
                base64Str = "data:application/msword;base64," + base64Str
        case "docx":
                base64Str = "data:application/vnd.openxmlformats-officedocument.wordprocessingml.document;base64," + base64Str
        case "txt":
                base64Str = "data:text/plain;base64," + base64Str
        case "xls":
                base64Str = "data:application/vnd.ms-excel;base64," + base64Str
        case "xlsx":
                base64Str = "data:application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;base64," + base64Str
        case "pdf":
                base64Str = "data:application/pdf;base64," + base64Str
        }
        return base64Str, nil
}

// 检测文档函数，传入文档格式、文档检测类型、文档本地存储路径
func FilledMsgFile(ftype string, ctype llmshield.ContentTypeV2, fileName string) *llmshield.MultiPart {
        dtstr, err := encodeFileToBase64(ftype, fileName)
        if err != nil {
                fmt.Printf("FilledMsgFile error: %v", err)
                return nil
        }

        msg_multi := &llmshield.MultiPart{
                Content:     dtstr,
                ContentType: ctype,
        }

        return msg_multi
}

// 图片Base64编码
func EncodeImageToBase64(imagePath string) (string, error) {
        // 读取图片文件内容
        data, err := os.ReadFile(imagePath)
        if err != nil {
                return "", fmt.Errorf("读取图片失败: %v", err)
        }
        // 进行Base64编码
        base64Str := base64.StdEncoding.EncodeToString(data)
        return base64Str, nil
}

// 检测图片函数，传入图片检测类型、图片本地存储路径
func FilledMsgImage(ctype llmshield.ContentTypeV2, imagePath string) *llmshield.MultiPart {
        dtstr, err := EncodeImageToBase64(imagePath)
        if err != nil {
                fmt.Printf("FilledMsgImage error: %v", err)
                return nil
        }

        msg_multi := &llmshield.MultiPart{
                Content:     dtstr,
                ContentType: ctype,
        }

        return msg_multi
}

func main() {
        var response *llmshield.ModerateV2Response
        var err error
        myUrl := "https://cn-beijing.sdk.access-test.llm-shield.omini-shield.com" // 根据大模型应用防火墙实例所在地域替换相应的地域信息
        ak := "YOUR AK"  // 火山账号的 AK
        sk := "YOUR SK"  // 火山账号的 SK
        appid := "app-d3r06khsqn9s73da****" // 资产的 AppId，可在控制台资产管理页面获取
        region := "cn-beijing" // 大模型应用防火墙实例所在地域
        timeout := time.Second * 60 // 超时时间
        
        request := llmshield.ModerateV2Request{
                Message: nil,
                Scene:   appid,
        }

        // 创建客户端实例
        client := llmshield.NewAdvanced(myUrl, ak, sk, region, timeout, "http://10.37.**.**:8888", 30) // 其中 "http://10.37.**.**:8888" 为代理地址示例值、30 为最大连接数示例值
        if client == nil {
                fmt.Printf("Failed to create client instance
")
                return
        }
        // 多模态混合检测文档
        part_file := FilledMsgFile("docx", llmshield.ContentTypeV2_FILE, "/Users/example/filedemo.docx")
        // 多模态混合检测图片
        part_image := FilledMsgImage(llmshield.ContentTypeV2_IMAGE, "/Users/example/imagedemo.png")
        // 多模态混合检测文本
        part_content := &llmshield.MultiPart{
                Content:     "网上都说A地很多骗子和小偷，他们的典型伎俩...", // 示例文本
                ContentType: llmshield.ContentTypeV2_TEXT,
        }
        
        request.Message = &llmshield.MessageV2{
                Role:      "user",
                MultiPart: []*llmshield.MultiPart{part_content, part_image, part_file},
        }

        response, err = client.Moderate(&request)
        if err != nil {
                fmt.Printf("Error occurred while checking LLM response stream: %v
", err)
        }
        if response == nil {
                fmt.Println("Received empty result")
        }
        fmt.Printf("Received result: %s
", response.String())
}

生成安全代答内容

适用场景：如果需要获取安全可靠的模型代答内容以响应用户，可调用此接口。接口将以流式方式返回响应内容，确保输出内容的安全性，避免恶意内容或敏感信息。
调用方法：
1. 调用moderate接口，将内容传入 SDK 进行校验，获取 MsgID。
2. 调用generate 接口，传入 MsgID 和内容相关参数，即可得到优化的代答结果，结果将以流式方式返回。
接口说明：详细接口说明请参见生成安全代答内容。

注意

使用流式检测时，需要待检测完全结束（最后一次传入 usestream=2）并返回结果后，才能调用代答接口，否则可能会导致调用失败。

无代理服务

有代理服务

package main 
 
import ( 
    "bufio" 
    "encoding/json" 
    "fmt" 
    "github.com/volcengine/volcengine-go-sdk/service/llmshield" 
    "io" 
    "log" 
    "os" 
    "strings" 
    "time" 
) 
 
func main() { 
    var err error 
    myUrl := "https://cn-beijing.sdk.access.llm-shield.omini-shield.com"   // 根据大模型应用防火墙实例所在地域替换相应的地域信息 
    ak := "YOUR AK"              // 火山账号的 AK
    sk := "YOUR SK"              // 火山账号的 SK
    appid := "app-d2pgblcjslsilvcv****"             // 资产的 AppId，可在控制台获取 
    region := "cn-beijing"              // 大模型应用防火墙实例所在地域 
    timeout := time.Second * 30         // 超时时间 
  
    // 创建客户端实例 
    client := llmshield.New(myUrl, ak, sk, region, timeout) 
    if client == nil { 
        fmt.Printf("Failed to create client instance
") 
        return 
    } 
    checkRequest := llmshield.ModerateV2Request{ 
        Message: nil, 
        Scene:   appid, 
    } 
 
    checkRequest.Message = &llmshield.MessageV2{ 
        Content:     "网上都说A地很多骗子和小偷，他们的典型伎俩...", 
        ContentType: llmshield.ContentTypeV2_TEXT, 
        Role:        "user",  // 检测的内容来源，user-用户提示词
    } 
    // 首先您需要先进行判别，获取到MsgID 
    checkResp, err := client.Moderate(&checkRequest) 
    if err != nil || checkResp == nil { 
        fmt.Printf("Failed to check response data
") 
        return 
    } 
    if checkResp.ResponseMetadata.Error != nil { 
        fmt.Printf("Server Return Error:%v", checkResp.ResponseMetadata.Error.Message) 
    } 
    if checkResp.Result.Decision.DecisionType != llmshield.DecisionTypeV2_OPTIMIZE { 
        // 您可以选择在命中代答动作后再进行代答，也可以根据具体业务需求来决定后续的处理逻辑。 SDK支持对任何动作进行代答
        fmt.Printf("您校验的内容无需代答。
") 
        return 
    } 
    request := llmshield.GenerateStreamV2Request{ 
        MsgID: checkResp.Result.MsgID, // 这是您通过审核接口进行校验后得到的MsgID 
    } 
    response, err := client.GenerateV2Stream(&request) 
    if err != nil { 
        log.Fatalf("Failed to start SSE stream: %v", err) 
    } 
    defer response.Reader.Close() 
    bufReader := bufio.NewReader(response.Reader) 
    for { 
        line, err := bufReader.ReadBytes('
') 
        if err != nil { 
            if err == io.EOF { 
                break 
            } 
            fmt.Fprintf(os.Stderr, "读取失败: %v
", err) 
            os.Exit(1) 
        } 
 
        // 去除换行符 
        line = line[:len(line)-1] 
 
        // 忽略空行 
        if len(line) == 0 { 
            continue 
        } 
        // SSE 数据以 "data: " 开头 
        if strings.HasPrefix(string(line), "data:") { 
            data := strings.TrimSpace(string(line[5:])) 
            if string(data) == "[DONE]" { 
                fmt.Println("收到 data: [DONE]，关闭连接") 
                break 
            } 
            var ResponseData llmshield.GenerateStreamV2ResponseData 
            err := json.Unmarshal([]byte(data), &ResponseData) 
            if err != nil { 
                fmt.Fprintf(os.Stderr, "反序列化失败: %v
", err) 
                continue 
            } 
            tempString, err := json.Marshal(ResponseData) 
            if err != nil { 
                fmt.Printf("Failed to marshal response to JSON: %v
", err) 
                return 
 
            } 
 
            if ResponseData.Result.IsFinished == true { 
                fmt.Printf("Received result: finish:%s
", string(tempString)) 
            } else { 
                fmt.Printf("Received result: %s
", string(tempString)) 
 
            } 
        } 
    } 
}

package main 
 
import ( 
    "bufio" 
    "encoding/json" 
    "fmt" 
    "github.com/volcengine/volcengine-go-sdk/service/llmshield" 
    "io" 
    "log" 
    "os" 
    "strings" 
    "time" 
) 
 
func main() { 
    var err error 
    myUrl := "https://cn-beijing.sdk.access.llm-shield.omini-shield.com"   // 根据大模型应用防火墙实例所在地域替换相应的地域信息 
    ak := "YOUR AK"              // 火山账号的 AK
    sk := "YOUR SK"              // 火山账号的 SK
    appid := "app-d2pgblcjslsilvcv****"             // 资产的 AppId，可在控制台获取 
    region := "cn-beijing"              // 大模型应用防火墙实例所在地域 
    timeout := time.Second * 30         // 超时时间 
  
    // 创建客户端实例 
    client := llmshield.NewAdvanced(myUrl, ak, sk, region, timeout, "http://10.37.**.**:8888", 30) // 其中 "http://10.37.**.**:8888" 为代理地址示例值、30 为最大连接数示例值
    if client == nil { 
        fmt.Printf("Failed to create client instance
") 
        return 
    } 
    checkRequest := llmshield.ModerateV2Request{ 
        Message: nil, 
        Scene:   appid, 
    } 
 
    checkRequest.Message = &llmshield.MessageV2{ 
        Content:     "网上都说A地很多骗子和小偷，他们的典型伎俩...", 
        ContentType: llmshield.ContentTypeV2_TEXT, 
        Role:        "user",  // 检测的内容来源，user-用户提示词
    } 
    // 首先您需要先进行判别，获取到MsgID 
    checkResp, err := client.Moderate(&checkRequest) 
    if err != nil || checkResp == nil { 
        fmt.Printf("Failed to check response data
") 
        return 
    } 
    if checkResp.ResponseMetadata.Error != nil { 
        fmt.Printf("Server Return Error:%v", checkResp.ResponseMetadata.Error.Message) 
    } 
    if checkResp.Result.Decision.DecisionType != llmshield.DecisionTypeV2_OPTIMIZE { 
        // 您可以选择在命中代答动作后再进行代答，也可以根据具体业务需求来决定后续的处理逻辑。 SDK支持对任何动作进行代答
        fmt.Printf("您校验的内容无需代答。
") 
        return 
    } 
    request := llmshield.GenerateStreamV2Request{ 
        MsgID: checkResp.Result.MsgID, // 这是您通过审核接口进行校验后得到的MsgID 
    } 
    response, err := client.GenerateV2Stream(&request) 
    if err != nil { 
        log.Fatalf("Failed to start SSE stream: %v", err) 
    } 
    defer response.Reader.Close() 
    bufReader := bufio.NewReader(response.Reader) 
    for { 
        line, err := bufReader.ReadBytes('
') 
        if err != nil { 
            if err == io.EOF { 
                break 
            } 
            fmt.Fprintf(os.Stderr, "读取失败: %v
", err) 
            os.Exit(1) 
        } 
 
        // 去除换行符 
        line = line[:len(line)-1] 
 
        // 忽略空行 
        if len(line) == 0 { 
            continue 
        } 
        // SSE 数据以 "data: " 开头 
        if strings.HasPrefix(string(line), "data:") { 
            data := strings.TrimSpace(string(line[5:])) 
            if string(data) == "[DONE]" { 
                fmt.Println("收到 data: [DONE]，关闭连接") 
                break 
            } 
            var ResponseData llmshield.GenerateStreamV2ResponseData 
            err := json.Unmarshal([]byte(data), &ResponseData) 
            if err != nil { 
                fmt.Fprintf(os.Stderr, "反序列化失败: %v
", err) 
                continue 
            } 
            tempString, err := json.Marshal(ResponseData) 
            if err != nil { 
                fmt.Printf("Failed to marshal response to JSON: %v
", err) 
                return 
 
            } 
 
            if ResponseData.Result.IsFinished == true { 
                fmt.Printf("Received result: finish:%s
", string(tempString)) 
            } else { 
                fmt.Printf("Received result: %s
", string(tempString)) 
 
            } 
        } 
    } 
}

最近更新时间：2025.12.26 14:43:46

这个页面对您有帮助吗？

有用

无用