package main

import (
	"context"
	"errors"
	"fmt"
	"io
	openai "github.com/sashabaranov/go-openai"
)

func main() {
	c := openai.NewClient("your token")
	ctx := context.Background()

	req := openai.ChatCompletionRequest{
		Model:     openai.GPT3Dot5Turbo,
		MaxTokens: 20,
		Messages: []openai.ChatCompletionMessage{
			{
				Role:    openai.ChatMessageRoleUser,
				Content: "Lorem ipsum",
			},
		},
		Stream: true,
	}
	stream, err := c.CreateChatCompletionStream(ctx, req)
	if err != nil {
		fmt.Printf("ChatCompletionStream error: %v\n", err)
		return
	}
	defer stream.Close()

	fmt.Printf("流式响应：")
	for {
		response, err := stream.Recv()
		if errors.Is(err, io.EOF) {
			fmt.Println("\n流式结束")
			return
		}

		if err != nil {
			fmt.Printf("\n流式错误：%v\n", err)
			return
		}

		fmt.Printf(response.Choices[0].Delta.Content)
	}
}

package main

import (
	"context"
	"fmt"
	openai "github.com/sashabaranov/go-openai"
)

func main() {
	c := openai.NewClient("your token")
	ctx := context.Background()

	req := openai.CompletionRequest{
		Model:     openai.GPT3Babbage002,
		MaxTokens: 5,
		Prompt:    "Lorem ipsum",
	}
	resp, err := c.CreateCompletion(ctx, req)
	if err != nil {
		fmt.Printf("Completion error: %v\n", err)
		return
	}
	fmt.Println(resp.Choices[0].Text)
}

package main

import (
	"errors"
	"context"
	"fmt"
	"io
	openai "github.com/sashabaranov/go-openai"
)

func main() {
	c := openai.NewClient("your token")
	ctx := context.Background()

	req := openai.CompletionRequest{
		Model:     openai.GPT3Babbage002,
		MaxTokens: 5,
		Prompt:    "Lorem ipsum",
		Stream:    true,
	}
	stream, err := c.CreateCompletionStream(ctx, req)
	if err != nil {
		fmt.Printf("CompletionStream error: %v\n", err)
		return
	}
	defer stream.Close()

	for {
		response, err := stream.Recv()
		if errors.Is(err, io.EOF) {
			fmt.Println("流式结束")
			return
		}

		if err != nil {
			fmt.Printf("流式错误：%v\n", err)
			return
		}

		fmt.Printf("流式响应：\n%s\n", response)
	}
}

package main

import (
	"context"
	"fmt"

	openai "github.com/sashabaranov/go-openai"
)

func main() {
	c := openai.NewClient("your token")
	ctx := context.Background()

	req := openai.AudioRequest{
		Model:    openai.Whisper1,
		FilePath: "recording.mp3",
	}
	resp, err := c.CreateTranscription(ctx, req)
	if err != nil {
		fmt.Printf("转录错误：%v\n", err)
		return
	}
	fmt.Println(resp.Text)
}

package main

import (
	"context"
	"fmt"
	"os

	openai "github.com/sashabaranov/go-openai"
)

func main() {
	c := openai.NewClient(os.Getenv("OPENAI_KEY"))

	req := openai.AudioRequest{
		Model:    openai.Whisper1,
		FilePath: os.Args[1],
		Format:   openai.AudioResponseFormatSRT,
	}
	resp, err := c.CreateTranscription(context.Background(), req)
	if err != nil {
		fmt.Printf("转录错误：%v\n", err)
		return
	}
	f, err := os.Create(os.Args[1] + ".srt")
	if err != nil {
		fmt.Printf("无法打开文件：%v\n", err)
		return
	}
	defer f.Close()
	if _, err := f.WriteString(resp.Text); err != nil {
		fmt.Printf("写入文件时出错：%v\n", err)
		return
	}
}

package main

import (
	"bytes"
	"context"
	"encoding/base64"
	"fmt"
	openai "github.com/sashabaranov/go-openai"
	"image/png"
	"os"
)

func main() {
	c := openai.NewClient("your token")
	ctx := context.Background()

	// 通过链接生成示例图像
	reqUrl := openai.ImageRequest{
		Prompt:         "一只鹦鹉在滑板上表演技巧，卡通风格，自然光，高细节",
		Size:           openai.CreateImageSize256x256,
		ResponseFormat: openai.CreateImageResponseFormatURL,
		N:              1,
	}

	respUrl, err := c.CreateImage(ctx, reqUrl)
	if err != nil {
		fmt.Printf("图像生成错误：%v\n", err)
		return
	}
	fmt.Println(respUrl.Data[0].URL)

	// 示例图像以 base64 格式
	reqBase64 := openai.ImageRequest{
		Prompt:         "一个人形鹦鹉穿着经典服装的肖像，高细节，逼真的光线，虚幻引擎效果",
		Size:           openai.CreateImageSize256x256,
		ResponseFormat: openai.CreateImageResponseFormatB64JSON,
		N:              1,
	}

	respBase64, err := c.CreateImage(ctx, reqBase64)
	if err != nil {
		fmt.Printf("图像生成错误：%v\n", err)
		return
	}

	imgBytes, err := base64.StdEncoding.DecodeString(respBase64.Data[0].B64JSON)
	if err != nil {
		fmt.Printf("Base64 解码错误：%v\n", err)
		return
	}

	r := bytes.NewReader(imgBytes)
	imgData, err := png.Decode(r)
	if err != nil {
		fmt.Printf("PNG 解码错误：%v\n", err)
		return
	}

文件, err := os.Create("example.png")
	if err != nil {
		fmt.Printf("创建文件错误：：%v\n", err)
		return
	}
	defer file.Close()

	if err := png.Encode(file, imgData); err != nil {
		fmt.Printf("PNG编码错误：：%v\n", err)
		return
	}

	fmt.Println("图像已保存为example.png")
}

package main

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

	openai "github.com/sashabaranov/go-openai"
)

func main() {
	c := openai.NewClient("your token")
	ctx := context.Background()

	req := openai.ImageRequest{
		Prompt:            "一只鹦鹉在滑板上表演特技。图片底部有一条醒目的横幅，上面写着‘SKATE MASTER’。卡通风格，自然光，高细节，1:1长宽比。",
		Background:        openai.CreateImageBackgroundOpaque,
		Model:             openai.CreateImageModelGptImage1,
		Size:              openai.CreateImageSize1024x1024,
		N:                 1,
		Quality:           openai.CreateImageQualityLow,
		OutputCompression: 100,
		OutputFormat:      openai.CreateImageOutputFormatJPEG,
		// Moderation: 		 openai.CreateImageModerationLow,
		// User: 					 "",
	}

	resp, err := c.CreateImage(ctx, req)
	if err != nil {
		fmt.Printf("图像生成错误：：%v\n", err)
		return
	}

	fmt.Println("图像Base64:", resp.Data[0].B64JSON)

	// 解码Base64数据
	imgBytes, err := base64.StdEncoding.DecodeString(resp.Data[0].B64JSON)
	if err != nil {
		fmt.Printf("Base64解码错误：：%v\n", err)
		return
	}

	// 将图像写入文件
	outputPath := "generated_image.jpg"
	err = os.WriteFile(outputPath, imgBytes, 0644)
	if err != nil {
		fmt.Printf("写入图像文件失败：：%v\n", err)
		return
	}

	fmt.Printf("图像已保存为%s\n", outputPath)
}

config := openai.DefaultConfig("token")
proxyUrl, err := url.Parse("http://localhost:{port}")
if err != nil {
	panic(err)
}
transport := &http.Transport{
	Proxy: http.ProxyURL(proxyUrl),
}
config.HTTPClient = &http.Client{
	Transport: transport,
}

c := openai.NewClientWithConfig(config)

参见：https://pkg.go.dev/github.com/sashabaranov/go-openai#ClientConfig

package main

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

	"github.com/sashabaranov/go-openai"
)

func main() {
	client := openai.NewClient("your token")
	messages := make([]openai.ChatCompletionMessage, 0)
	reader := bufio.NewReader(os.Stdin)
	fmt.Println("对话")
	fmt.Println("---------------------")

	for {
		fmt.Print("-> ")
		text, _ := reader.ReadString('\n')
		// 将CRLF转换为LF
		text = strings.Replace(text, "\n", "", -1)
		messages = append(messages, openai.ChatCompletionMessage{
			Role:    openai.ChatMessageRoleUser,
			Content: text,
		})

		resp, err := client.CreateChatCompletion(
			context.Background(),
			openai.ChatCompletionRequest{
				Model:    openai.GPT3Dot5Turbo,
				Messages: messages,
			},
		)

		if err != nil {
			fmt.Printf("ChatCompletion错误：：%v\n", err)
			continue
		}

		content := resp.Choices[0].Message.Content
		messages = append(messages, openai.ChatCompletionMessage{
			Role:    openai.ChatMessageRoleAssistant,
			Content: content,
		})
		fmt.Println(content)
	}
}

package main

import (
	"context"
	"fmt"

	openai "github.com/sashabaranov/go-openai"
)

func main() {
	config := openai.DefaultAzureConfig("your Azure OpenAI Key", "https://your Azure OpenAI Endpoint")
	// 如果你使用的部署名称与模型名称不同，可以自定义AzureModelMapperFunc函数
	// config.AzureModelMapperFunc = func(model string) string {
	// 	azureModelMapping := map[string]string{
	// 		"gpt-3.5-turbo": "your gpt-3.5-turbo部署名称",
	// 	}
	// 	return azureModelMapping[model]
	// }

	client := openai.NewClientWithConfig(config)
	resp, err := client.CreateChatCompletion(
		context.Background(),
		openai.ChatCompletionRequest{
			Model: openai.GPT3Dot5Turbo,
			Messages: []openai.ChatCompletionMessage{
				{
					Role:    openai.ChatMessageRoleUser,
					Content: "Hello Azure OpenAI!",
				},
			},
		},
	)
	if err != nil {
		fmt.Printf("ChatCompletion错误：：%v\n", err)
		return
	}

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

package main

import (
	"context"
	"log"
	openai "github.com/sashabaranov/go-openai"

)

func main() {
	client := openai.NewClient("your-token")

	// 为用户查询创建一个EmbeddingRequest
	queryReq := openai.EmbeddingRequest{
		Input: []string{"一只土拨鼠能刨多少土？"},
		Model: openai.AdaEmbeddingV2,
	}

	// 为用户查询创建嵌入向量
queryResponse, err := client.CreateEmbeddings(context.Background(), queryReq)
if err != nil {
	log.Fatal("创建查询嵌入向量时出错：", err)
}

	// 为目标文本创建一个EmbeddingRequest
targetReq := openai.EmbeddingRequest{
	 Input: []string{"如果土拨鼠真的会刨土，它能刨多少土呢？"},
	 Model: openai.AdaEmbeddingV2,
}

	// 为目标文本创建嵌入向量
targetResponse, err := client.CreateEmbeddings(context.Background(), targetReq)
if err != nil {
	log.Fatal("创建目标嵌入向量时出错：", err)
}

	// 现在我们已经有了用户查询和目标文本的嵌入向量，就可以计算它们之间的相似度了。
queryEmbedding := queryResponse.Data[0]
targetEmbedding := targetResponse.Data[0]

similarity, err := queryEmbedding.DotProduct(&targetEmbedding)
if err != nil {
	log.Fatal("计算点积时出错：", err)
}

log.Printf("查询和目标文本之间的相似度分数为%f", similarity)
}

package main

import (
	"context"
	"fmt"

	openai "github.com/sashabaranov/go-openai"
)

func main() {

	config := openai.DefaultAzureConfig("your Azure OpenAI Key", "https://your Azure OpenAI Endpoint")
	config.APIVersion = "2023-05-15" // 可选地更新到最新API版本

	// 如果你使用的部署名称与模型名称不同，可以自定义AzureModelMapperFunc函数
	//config.AzureModelMapperFunc = func(model string) string {
	//    azureModelMapping := map[string]string{
	//        "gpt-3.5-turbo":"your gpt-3.5-turbo部署名称",
	//    }
	//    return azureModelMapping[model]
	//}

input := "需要向量化处理的文本"

client := openai.NewClientWithConfig(config)
resp, err := client.CreateEmbeddings(
	context.Background(),
	openai.EmbeddingRequest{
		Input: []string{input},
		Model: openai.AdaEmbeddingV2,
	},
)
if err != nil {
	fmt.Printf("CreateEmbeddings错误：：%v\n", err)
	return
}

向量 := resp.Data[0].Embedding // 一个包含1536维浮点数的数组

fmt.Println(vectors[:10], "...", vectors[len(vectors)-10:])
}

现在，聊天补全功能可以选择调用函数以获取更多信息（请参阅此处的开发者文档）。

为了描述可调用函数的类型，必须提供一个 JSON Schema。虽然有许多比本库所能提供的更为先进的 JSON Schema 库，但我们仍包含了一个简单的 jsonschema 包，供希望使用此功能而无需自行格式化 JSON Schema 负载的人士使用。

开发者文档中给出了如下 JSON Schema 定义作为示例：

{
  "name":"get_current_weather",
  "description":"获取给定地点的当前天气",
  "parameters":{
    "type":"object",
    "properties":{
        "location":{
          "type":"string",
          "description":"城市和州，例如旧金山，加州"
        },
        "unit":{
          "type":"string",
          "enum":[
              "celsius",
              "fahrenheit"
          ]
        }
    },
    "required":[
        "location"
    ]
  }
}

使用 jsonschema 包，可以通过结构体创建该 Schema，如下所示：

FunctionDefinition{
  Name: "get_current_weather",
  Parameters: jsonschema.Definition{
    Type: jsonschema.Object,
    Properties: map[string]jsonschema.Definition{
      "location": {
        Type: jsonschema.String,
        Description: "城市和州，例如旧金山，加州",
      },
      "unit": {
        Type: jsonschema.String,
        Enum: []string{"celsius", "fahrenheit"},
      },
    },
    Required: []string{"location"},
  },
}

FunctionDefinition 的 Parameters 字段可以接受上述任一格式，甚至可以接受来自其他库的嵌套结构体（只要能够被序列化为 JSON 即可）。

OpenAI 维护了清晰的文档，说明如何 处理 API 错误。

示例：

e := &openai.APIError{}
if errors.As(err, &e) {
  switch e.HTTPStatusCode {
    case 401:
      // 认证或密钥无效（不要重试）
    case 429:
      // 速率限制或引擎过载（等待后重试）
    case 500:
      // OpenAI 服务器错误（重试）
    default:
      // 未处理的情况
  }
}

package main

import (
	"context"
	"fmt"
	"github.com/sashabaranov/go-openai"
)

func main() {
	client := openai.NewClient("your token")
	ctx := context.Background()

	// 创建一个包含对话模型训练数据的 .jsonl 文件
	// {"prompt": "<提示文本>", "completion": "<理想生成文本>"}
	// {"prompt": "<提示文本>", "completion": "<理想生成文本>"}
	// {"prompt": "<提示文本>", "completion": "<理想生成文本>"}

	// 对话模型使用以下文件格式进行训练：
	// {"messages": [{"role": "system", "content": "Marv 是一个既基于事实又带讽刺意味的聊天机器人。"}, {"role": "user", "content": "法国的首都是哪里？"}, {"role": "assistant", "content": "巴黎，好像大家都知道似的。"}]}
	// {"messages": [{"role": "system", "content": "Marv 是一个既基于事实又带讽刺意味的聊天机器人。"}, {"role": "user", "content": "《罗密欧与朱丽叶》是谁写的？"}, {"role": "assistant", "content": "哦，就是那个叫威廉·莎士比亚的人呗。你听说过他吗？"}]}
	// {"messages": [{"role": "system", "content": "Marv 是一个既基于事实又带讽刺意味的聊天机器人。"}, {"role": "user", "content": "月球离地球有多远？"}, {"role": "assistant", "content": "大约 384,400 公里吧。多一点少一点也没啥关系，反正谁在乎呢。"}]}

	// 可以使用 OpenAI CLI 工具来验证数据。
	// 更多信息请参阅：https://platform.openai.com/docs/guides/fine-tuning

	file, err := client.CreateFile(ctx, openai.FileRequest{
		FilePath: "training_prepared.jsonl",
		Purpose:  "fine-tune",
	})
	if err != nil {
		fmt.Printf("上传 JSONL 文件时出错：%v\n", err)
		return
	}

	// 创建微调任务
	// 流式传输事件直到任务完成（这通常需要几分钟，但如果队列中有许多任务或您的数据集很大，则可能需要数小时）。
	// 使用下面的方法来了解模型的状态。
	fineTuningJob, err := client.CreateFineTuningJob(ctx, openai.FineTuningJobRequest{
		TrainingFile: file.ID,
		Model:        "davinci-002", // gpt-3.5-turbo-0613、babbage-002。
	})
	if err != nil {
		fmt.Printf("创建新的微调模型时出错：%v\n", err)
		return
	}

	fineTuningJob, err = client.RetrieveFineTuningJob(ctx, fineTuningJob.ID)
	if err != nil {
		fmt.Printf("获取微调模型时出错：%v\n", err)
		return
	}
	fmt.Println(fineTuningJob.FineTunedModel)

	// 一旦 fineTuningJob 的状态变为 `succeeded`，您就可以在 Completion Request 或 Chat Completion Request 中使用您的微调模型。

	// resp, err := client.CreateCompletion(ctx, openai.CompletionRequest{
	//	 Model:  fineTuningJob.FineTunedModel,
	//	 Prompt: "your prompt",
	// })
	// if err != nil {
	//	 fmt.Printf("创建完成请求时出错：%v\n", err)
	//	 return
	// }
	//
	// fmt.Println(resp.Choices[0].Text)
}

package main

import (
	"context"
	"fmt"
	"log"

	"github.com/sashabaranov/go-openai"
	"github.com/sashabaranov/go-openai/jsonschema"
)

func main() {
	client := openai.NewClient("your token")
	ctx := context.Background()

	type Result struct {
		Steps []struct {
			Explanation string `json:"explanation"`
			Output      string `json:"output"`
		} `json:"steps"`
		FinalAnswer string `json:"final_answer"`
	}
	var result Result
	schema, err := jsonschema.GenerateSchemaForType(result)
	if err != nil {
		log.Fatalf("GenerateSchemaForType 出错：%v", err)
	}
	resp, err := client.CreateChatCompletion(ctx, openai.ChatCompletionRequest{
		Model: openai.GPT4oMini,
		Messages: []openai.ChatCompletionMessage{
			{
				Role:    openai.ChatMessageRoleSystem,
				Content: "你是一位乐于助人的数学家教。请逐步引导用户解决问题。",
			},
			{
				Role:    openai.ChatMessageRoleUser,
				Content: "我该如何解方程 8x + 7 = -23",
			},
		},
		ResponseFormat: &openai.ChatCompletionResponseFormat{
			Type: openai.ChatCompletionResponseFormatTypeJSONSchema,
			JSONSchema: &openai.ChatCompletionResponseFormatJSONSchema{
				Name:   "math_reasoning",
				Schema: schema,
				Strict: true,
			},
		},
	})
	if err != nil {
		log.Fatalf("CreateChatCompletion 出错：%v", err)
	}
	err = schema.Unmarshal(resp.Choices[0].Message.Content, &result)
	if err != nil {
		log.Fatalf("Unmarshal schema 出错：%v", err)
	}
	fmt.Println(result)
}