Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/anhao/go-ernie
文心千帆 GO SDK ，文心一言
https://github.com/anhao/go-ernie
ernie go-ernie wenxin wenxinworkshop
Last synced: about 2 months ago
JSON representation
文心千帆 GO SDK ，文心一言
- Host: GitHub
- URL: https://github.com/anhao/go-ernie
- Owner: anhao
- License: apache-2.0
- Created: 2023-07-29T17:40:43.000Z (about 1 year ago)
- Default Branch: main
- Last Pushed: 2023-12-15T06:21:48.000Z (9 months ago)
- Last Synced: 2024-06-18T23:05:05.309Z (3 months ago)
- Topics: ernie, go-ernie, wenxin, wenxinworkshop
- Language: Go
- Homepage:
- Size: 27.3 KB
- Stars: 124
- Watchers: 4
- Forks: 11
- Open Issues: 2
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# 文心千帆 GO SDK
[](https://pkg.go.dev/github.com/anhao/go-ernie)
本库为文心千帆GO语言SDK，非官方库,目前官方还没有GO语言的SDK [文心千帆](https://cloud.baidu.com/product/wenxinworkshop)
已支持自动刷新 **accessToken**, 需要通过 **ernie.NewDefaultClient("API Key", "Secret Key")** 方式初始化客户端
目前支持的模型：
* ERNIE-Bot-4
* ERNIE-Bot
* ERNIE-Bot-turbo
* ERNIE-Bot-8k
* ERNIE-Bot-turbo-AI
* BLOOMZ-7B
* Llama-2
* Embeddings
* 百度云所有模型
### 安装
```go
go get github.com/anhao/go-ernie
```
需要 go 版本为 1.18+
### 使用示例
```go
package main
import (
"context"
"fmt"
ernie "github.com/anhao/go-ernie"
)
func main() {
client := ernie.NewDefaultClient("API Key", "Secret Key")
completion, err := client.CreateErnieBotChatCompletion(context.Background(), ernie.ErnieBotRequest{
Messages: []ernie.ChatCompletionMessage{
{
Role: ernie.MessageRoleUser,
Content: "你好呀",
},
},
})
if err != nil {
fmt.Printf("ernie bot error: %v\n", err)
return
}
fmt.Println(completion)
}
```
### 获取文心千帆 APIKEY
1. 在百度云官网进行申请：https://cloud.baidu.com/product/wenxinworkshop
2. 申请通过后创建应用：https://console.bce.baidu.com/qianfan/ais/console/applicationConsole/application
3. 获取 apikey 和 api secret
### 其他示例
ERNIE-Bot 4.0 对话
```go
import (
"context"
"errors"
"fmt"
ernie "github.com/anhao/go-ernie"
"io"
)
func main() {
client := ernie.NewDefaultClient("API Key", "Secret Key")
request := ernie.ErnieBot4Request{
Messages: []ChatCompletionMessage{
{
Role: "user",
Content: "Hello",
},
},
Stream: true,
}
stream, err := client.CreateErnieBot4ChatCompletionStream(context.Background(), request)
if err != nil {
fmt.Printf("ernie bot stream error: %v\n", err)
return
}
defer stream.Close()
for {
response, err := stream.Recv()
if errors.Is(err, io.EOF) {
fmt.Println("ernie bot 4 Stream finished")
return
}
if err != nil {
fmt.Printf("ernie bot 4 stream error: %v\n", err)
return
}
fmt.Println(response.Result)
}
}
```
ERNIE-Bot stream流 对话
```go
import (
"context"
"errors"
"fmt"
ernie "github.com/anhao/go-ernie"
"io"
)
func main() {
client := ernie.NewDefaultClient("API Key", "Secret Key")
request := ernie.ErnieBotRequest{
Messages: []ChatCompletionMessage{
{
Role: "user",
Content: "Hello",
},
},
Stream: true,
}
stream, err := client.CreateErnieBotChatCompletionStream(context.Background(), request)
if err != nil {
fmt.Printf("ernie bot stream error: %v\n", err)
return
}
defer stream.Close()
for {
response, err := stream.Recv()
if errors.Is(err, io.EOF) {
fmt.Println("ernie bot Stream finished")
return
}
if err != nil {
fmt.Printf("ernie bot stream error: %v\n", err)
return
}
fmt.Println(response.Result)
}
}
```
ERNIE-Bot-Turbo 对话
```go
package main
import (
"context"
"fmt"
ernie "github.com/anhao/go-ernie"
)
func main() {
client := ernie.NewDefaultClient("API Key", "Secret Key")
completion, err := client.CreateErnieBotTurboChatCompletion(context.Background(), ernie.ErnieBotTurboRequest{
Messages: []ernie.ChatCompletionMessage{
{
Role: ernie.MessageRoleUser,
Content: "你好呀",
},
},
})
if err != nil {
fmt.Printf("ernie bot turbo error: %v\n", err)
return
}
fmt.Println(completion)
}
```
ERNIE-Bot Turbo stream流 对话
```go
import (
"context"
"errors"
"fmt"
ernie "github.com/anhao/go-ernie"
"io"
)
func main() {
client := ernie.NewDefaultClient("API Key", "Secret Key")
request := ernie.ErnieBotTurboRequest{
Messages: []ChatCompletionMessage{
{
Role: "user",
Content: "Hello",
},
},
Stream: true,
}
stream, err := client.CreateErnieBotTurboChatCompletionStream(context.Background(), request)
if err != nil {
fmt.Printf("ernie bot stream error: %v\n", err)
return
}
defer stream.Close()
for {
response, err := stream.Recv()
if errors.Is(err, io.EOF) {
fmt.Println("ernie bot turbo Stream finished")
return
}
if err != nil {
fmt.Printf("ernie bot turbo stream error: %v\n", err)
return
}
fmt.Println(response.Result)
}
}
```
BLOOMZ-7B 对话
```go
package main
import (
"context"
"fmt"
ernie "github.com/anhao/go-ernie"
)
func main() {
client := ernie.NewDefaultClient("API Key", "Secret Key")
completion, err := client.CreateBloomz7b1ChatCompletion(context.Background(), ernie.Bloomz7b1Request{
Messages: []ernie.ChatCompletionMessage{
{
Role: ernie.MessageRoleUser,
Content: "你好呀",
},
},
})
if err != nil {
fmt.Printf("BLOOMZ-7B error: %v\n", err)
return
}
fmt.Println(completion)
}
```
BLOOMZ-7B stream流 对话
```go
import (
"context"
"errors"
"fmt"
ernie "github.com/anhao/go-ernie"
"io"
)
func main() {
client := ernie.NewDefaultClient("API Key", "Secret Key")
request := ernie.Bloomz7b1Request{
Messages: []ChatCompletionMessage{
{
Role: "user",
Content: "Hello",
},
},
Stream: true,
}
stream, err := client.CreateBloomz7b1ChatCompletionStream(context.Background(), request)
if err != nil {
fmt.Printf("BLOOMZ-7B error: %v\n", err)
return
}
defer stream.Close()
for {
response, err := stream.Recv()
if errors.Is(err, io.EOF) {
fmt.Println("BLOOMZ-7B Stream finished")
return
}
if err != nil {
fmt.Printf("BLOOMZ-7B stream error: %v\n", err)
return
}
fmt.Println(response.Result)
}
}
```
Llama2 对话
```go
package main
import (
"context"
"fmt"
ernie "github.com/anhao/go-ernie"
)
func main() {
client := ernie.NewDefaultClient("API Key", "Secret Key")
completion, err := client.CreateLlamaChatCompletion(context.Background(), ernie.LlamaChatRequest{
Messages: []ernie.ChatCompletionMessage{
{
Role: ernie.MessageRoleUser,
Content: "你好呀",
},
},
Model: "", //申请发布时填写的API名称
})
if err != nil {
fmt.Printf("llama2 error: %v\n", err)
return
}
fmt.Println(completion)
}
```
Llama2 stream流 对话
```go
import (
"context"
"errors"
"fmt"
ernie "github.com/anhao/go-ernie"
"io"
)
func main() {
client := ernie.NewDefaultClient("API Key", "Secret Key")
request := ernie.LlamaChatRequest{
Messages: []ChatCompletionMessage{
{
Role: "user",
Content: "Hello",
},
},
Stream: true,
Model: "", //申请发布时填写的API名称
}
stream, err := client.CreateLlamaChatCompletionStream(context.Background(), request)
if err != nil {
fmt.Printf("llama2 error: %v\n", err)
return
}
defer stream.Close()
for {
response, err := stream.Recv()
if errors.Is(err, io.EOF) {
fmt.Println("llama2 Stream finished")
return
}
if err != nil {
fmt.Printf("llama2 stream error: %v\n", err)
return
}
fmt.Println(response.Result)
}
}
```
Embedding向量
```go
package main
import (
"context"
"fmt"
ernie "github.com/anhao/go-ernie"
)
func main() {
client := ernie.NewDefaultClient("API Key", "Secret Key")
request := ernie.EmbeddingRequest{
Input: []string{
"Hello",
},
}
embeddings, err := client.CreateEmbeddings(context.Background(), request)
if err != nil {
fmt.Sprintf("embeddings err: %v", err)
return
}
fmt.Println(embeddings)
}
```
自定义 accessToken
```go
client :=ernie.NewClient("accessToken")
```
百度云其他Chat模型
百度云的其他模型需要自己部署，部署需要填写一个API地址
```go
import (
"context"
"errors"
"fmt"
ernie "github.com/anhao/go-ernie"
"io"
)
func main() {
client := ernie.NewDefaultClient("API Key", "Secret Key")
request := ernie.BaiduChatRequest{
Messages: []ChatCompletionMessage{
{
Role: "user",
Content: "Hello",
},
},
Stream: true,
Model: "", //申请发布时填写的API名称
}
stream, err := client.CreateBaiduChatCompletionStream(context.Background(), request)
if err != nil {
fmt.Printf("baidu chat error: %v\n", err)
return
}
defer stream.Close()
for {
response, err := stream.Recv()
if errors.Is(err, io.EOF) {
fmt.Println("baidu chat Stream finished")
return
}
if err != nil {
fmt.Printf("baidu chat stream error: %v\n", err)
return
}
fmt.Println(response.Result)
}
}
```
文本生成图片
百度云的其他模型需要自己部署，部署需要填写一个API地址
```go
import (
"context"
"errors"
"fmt"
ernie "github.com/anhao/go-ernie"
"io"
)
func main() {
client := ernie.NewDefaultClient("API Key", "Secret Key")
request := ernie.BaiduTxt2ImgRequest{
Model: "", //申请发布时填写的API名称
Prompt: "",//提示词
}
response, err := client.CreateBaiduTxt2Img(context.Background(), request)
if err != nil {
fmt.Printf("baidu txt2img error: %v\n", err)
return
}
fmt.Println(response)
}
```
插件应用
```go
import (
"context"
"errors"
"fmt"
ernie "github.com/anhao/go-ernie"
"io"
)
func main() {
client := ernie.NewDefaultClient("API Key", "Secret Key")
request := ernie.ErnieCustomPluginRequest{
PluginName: "xxx", // 插件名称
Query: "你好",// 查询信息
Stream: false,
}
response, err := client.CreateErnieCustomPluginChatCompletion(context.Background(), request)
if err != nil {
fmt.Printf("ernie custom plugins error: %v\n", err)
return
}
fmt.Println(response)
}
```