LocalAI/api/openai.go

679 lines
18 KiB
Go
Raw Normal View History

package api
import (
"bufio"
2023-05-02 18:03:35 +00:00
"bytes"
"encoding/base64"
"encoding/json"
"fmt"
"io"
"io/ioutil"
2023-05-09 09:43:50 +00:00
"net/http"
"os"
"path"
"path/filepath"
"strconv"
"strings"
2023-05-11 14:34:16 +00:00
"github.com/ggerganov/whisper.cpp/bindings/go/pkg/whisper"
model "github.com/go-skynet/LocalAI/pkg/model"
2023-05-11 14:34:16 +00:00
whisperutil "github.com/go-skynet/LocalAI/pkg/whisper"
llama "github.com/go-skynet/go-llama.cpp"
"github.com/gofiber/fiber/v2"
"github.com/rs/zerolog/log"
"github.com/valyala/fasthttp"
)
// APIError provides error information returned by the OpenAI API.
type APIError struct {
Code any `json:"code,omitempty"`
Message string `json:"message"`
Param *string `json:"param,omitempty"`
Type string `json:"type"`
}
type ErrorResponse struct {
Error *APIError `json:"error,omitempty"`
}
type OpenAIUsage struct {
PromptTokens int `json:"prompt_tokens"`
CompletionTokens int `json:"completion_tokens"`
TotalTokens int `json:"total_tokens"`
}
type Item struct {
Embedding []float32 `json:"embedding"`
Index int `json:"index"`
Object string `json:"object,omitempty"`
// Images
URL string `json:"url,omitempty"`
B64JSON string `json:"b64_json,omitempty"`
}
type OpenAIResponse struct {
Created int `json:"created,omitempty"`
Object string `json:"object,omitempty"`
ID string `json:"id,omitempty"`
Model string `json:"model,omitempty"`
Choices []Choice `json:"choices,omitempty"`
Data []Item `json:"data,omitempty"`
Usage OpenAIUsage `json:"usage"`
}
type Choice struct {
Index int `json:"index,omitempty"`
FinishReason string `json:"finish_reason,omitempty"`
Message *Message `json:"message,omitempty"`
Delta *Message `json:"delta,omitempty"`
Text string `json:"text,omitempty"`
}
type Message struct {
Role string `json:"role,omitempty" yaml:"role"`
Content string `json:"content,omitempty" yaml:"content"`
}
type OpenAIModel struct {
ID string `json:"id"`
Object string `json:"object"`
}
type OpenAIRequest struct {
Model string `json:"model" yaml:"model"`
2023-05-09 09:43:50 +00:00
// whisper
File string `json:"file" validate:"required"`
Language string `json:"language"`
//whisper/image
2023-05-09 09:43:50 +00:00
ResponseFormat string `json:"response_format"`
// image
Size string `json:"size"`
// Prompt is read only by completion/image API calls
Prompt interface{} `json:"prompt" yaml:"prompt"`
2023-04-29 07:22:09 +00:00
// Edit endpoint
Instruction string `json:"instruction" yaml:"instruction"`
Input interface{} `json:"input" yaml:"input"`
2023-04-29 07:22:09 +00:00
Stop interface{} `json:"stop" yaml:"stop"`
// Messages is read only by chat/completion API calls
Messages []Message `json:"messages" yaml:"messages"`
Stream bool `json:"stream"`
Echo bool `json:"echo"`
// Common options between all the API calls
TopP float64 `json:"top_p" yaml:"top_p"`
TopK int `json:"top_k" yaml:"top_k"`
Temperature float64 `json:"temperature" yaml:"temperature"`
Maxtokens int `json:"max_tokens" yaml:"max_tokens"`
N int `json:"n"`
// Custom parameters - not present in the OpenAI API
Batch int `json:"batch" yaml:"batch"`
F16 bool `json:"f16" yaml:"f16"`
IgnoreEOS bool `json:"ignore_eos" yaml:"ignore_eos"`
RepeatPenalty float64 `json:"repeat_penalty" yaml:"repeat_penalty"`
Keep int `json:"n_keep" yaml:"n_keep"`
2023-05-05 11:45:37 +00:00
MirostatETA float64 `json:"mirostat_eta" yaml:"mirostat_eta"`
MirostatTAU float64 `json:"mirostat_tau" yaml:"mirostat_tau"`
Mirostat int `json:"mirostat" yaml:"mirostat"`
Seed int `json:"seed" yaml:"seed"`
// Image (not supported by OpenAI)
Mode int `json:"mode"`
Step int `json:"step"`
}
func defaultRequest(modelFile string) OpenAIRequest {
return OpenAIRequest{
TopP: 0.7,
TopK: 80,
Maxtokens: 512,
Temperature: 0.9,
Model: modelFile,
}
}
2023-04-29 07:22:09 +00:00
// https://platform.openai.com/docs/api-reference/completions
2023-05-21 12:38:25 +00:00
func completionEndpoint(cm *ConfigMerger, o *Option) func(c *fiber.Ctx) error {
2023-04-29 07:22:09 +00:00
return func(c *fiber.Ctx) error {
2023-05-21 12:38:25 +00:00
model, input, err := readInput(c, o.loader, true)
if err != nil {
return fmt.Errorf("failed reading parameters from request:%w", err)
}
2023-05-21 12:38:25 +00:00
config, input, err := readConfig(model, input, cm, o.loader, o.debug, o.threads, o.ctxSize, o.f16)
2023-04-29 07:22:09 +00:00
if err != nil {
return fmt.Errorf("failed reading parameters from request:%w", err)
}
log.Debug().Msgf("Parameter Config: %+v", config)
templateFile := config.Model
2023-04-29 07:22:09 +00:00
if config.TemplateConfig.Completion != "" {
templateFile = config.TemplateConfig.Completion
}
var result []Choice
for _, i := range config.PromptStrings {
// A model can have a "file.bin.tmpl" file associated with a prompt template prefix
2023-05-21 12:38:25 +00:00
templatedInput, err := o.loader.TemplatePrefix(templateFile, struct {
Input string
}{Input: i})
if err == nil {
i = templatedInput
log.Debug().Msgf("Template found, input modified to: %s", i)
}
2023-05-21 12:38:25 +00:00
r, err := ComputeChoices(i, input, config, o.loader, func(s string, c *[]Choice) {
*c = append(*c, Choice{Text: s})
}, nil)
if err != nil {
return err
}
result = append(result, r...)
2023-04-29 07:22:09 +00:00
}
2023-04-29 07:22:09 +00:00
resp := &OpenAIResponse{
Model: input.Model, // we have to return what the user sent here, due to OpenAI spec.
Choices: result,
Object: "text_completion",
}
2023-04-29 07:22:09 +00:00
jsonResult, _ := json.Marshal(resp)
log.Debug().Msgf("Response: %s", jsonResult)
// Return the prediction in the response body
return c.JSON(resp)
}
}
// https://platform.openai.com/docs/api-reference/embeddings
2023-05-21 12:38:25 +00:00
func embeddingsEndpoint(cm *ConfigMerger, o *Option) func(c *fiber.Ctx) error {
return func(c *fiber.Ctx) error {
2023-05-21 12:38:25 +00:00
model, input, err := readInput(c, o.loader, true)
if err != nil {
return fmt.Errorf("failed reading parameters from request:%w", err)
}
2023-05-21 12:38:25 +00:00
config, input, err := readConfig(model, input, cm, o.loader, o.debug, o.threads, o.ctxSize, o.f16)
if err != nil {
return fmt.Errorf("failed reading parameters from request:%w", err)
}
log.Debug().Msgf("Parameter Config: %+v", config)
items := []Item{}
for i, s := range config.InputToken {
// get the model function to call for the result
2023-05-21 12:38:25 +00:00
embedFn, err := ModelEmbedding("", s, o.loader, *config)
if err != nil {
return err
}
embeddings, err := embedFn()
if err != nil {
return err
}
items = append(items, Item{Embedding: embeddings, Index: i, Object: "embedding"})
}
for i, s := range config.InputStrings {
// get the model function to call for the result
2023-05-21 12:38:25 +00:00
embedFn, err := ModelEmbedding(s, []int{}, o.loader, *config)
if err != nil {
return err
}
embeddings, err := embedFn()
if err != nil {
return err
}
items = append(items, Item{Embedding: embeddings, Index: i, Object: "embedding"})
}
resp := &OpenAIResponse{
Model: input.Model, // we have to return what the user sent here, due to OpenAI spec.
Data: items,
Object: "list",
}
jsonResult, _ := json.Marshal(resp)
log.Debug().Msgf("Response: %s", jsonResult)
// Return the prediction in the response body
return c.JSON(resp)
}
}
2023-05-21 12:38:25 +00:00
func chatEndpoint(cm *ConfigMerger, o *Option) func(c *fiber.Ctx) error {
process := func(s string, req *OpenAIRequest, config *Config, loader *model.ModelLoader, responses chan OpenAIResponse) {
initialMessage := OpenAIResponse{
Model: req.Model, // we have to return what the user sent here, due to OpenAI spec.
Choices: []Choice{{Delta: &Message{Role: "assistant"}}},
Object: "chat.completion.chunk",
}
responses <- initialMessage
ComputeChoices(s, req, config, loader, func(s string, c *[]Choice) {}, func(s string) bool {
resp := OpenAIResponse{
Model: req.Model, // we have to return what the user sent here, due to OpenAI spec.
Choices: []Choice{{Delta: &Message{Content: s}}},
Object: "chat.completion.chunk",
}
log.Debug().Msgf("Sending goroutine: %s", s)
responses <- resp
return true
})
close(responses)
}
2023-04-29 07:22:09 +00:00
return func(c *fiber.Ctx) error {
2023-05-21 12:38:25 +00:00
model, input, err := readInput(c, o.loader, true)
if err != nil {
return fmt.Errorf("failed reading parameters from request:%w", err)
}
2023-05-21 12:38:25 +00:00
config, input, err := readConfig(model, input, cm, o.loader, o.debug, o.threads, o.ctxSize, o.f16)
if err != nil {
2023-04-29 07:22:09 +00:00
return fmt.Errorf("failed reading parameters from request:%w", err)
}
2023-04-29 07:22:09 +00:00
log.Debug().Msgf("Parameter Config: %+v", config)
2023-04-29 07:22:09 +00:00
var predInput string
2023-04-29 07:22:09 +00:00
mess := []string{}
for _, i := range input.Messages {
2023-05-17 19:01:46 +00:00
var content string
2023-04-29 07:22:09 +00:00
r := config.Roles[i.Role]
2023-05-17 19:01:46 +00:00
if r != "" {
content = fmt.Sprint(r, " ", i.Content)
} else {
content = i.Content
}
2023-04-29 07:22:09 +00:00
mess = append(mess, content)
}
2023-04-29 07:22:09 +00:00
predInput = strings.Join(mess, "\n")
2023-04-29 07:22:09 +00:00
if input.Stream {
log.Debug().Msgf("Stream request received")
2023-05-02 18:03:35 +00:00
c.Context().SetContentType("text/event-stream")
2023-04-29 07:22:09 +00:00
//c.Response().Header.SetContentType(fiber.MIMETextHTMLCharsetUTF8)
2023-05-02 18:03:35 +00:00
// c.Set("Content-Type", "text/event-stream")
2023-04-29 07:22:09 +00:00
c.Set("Cache-Control", "no-cache")
c.Set("Connection", "keep-alive")
c.Set("Transfer-Encoding", "chunked")
}
2023-04-29 07:22:09 +00:00
templateFile := config.Model
if config.TemplateConfig.Chat != "" {
templateFile = config.TemplateConfig.Chat
}
// A model can have a "file.bin.tmpl" file associated with a prompt template prefix
2023-05-21 12:38:25 +00:00
templatedInput, err := o.loader.TemplatePrefix(templateFile, struct {
2023-04-29 07:22:09 +00:00
Input string
}{Input: predInput})
if err == nil {
predInput = templatedInput
log.Debug().Msgf("Template found, input modified to: %s", predInput)
}
if input.Stream {
2023-05-02 18:03:35 +00:00
responses := make(chan OpenAIResponse)
2023-05-21 12:38:25 +00:00
go process(predInput, input, config, o.loader, responses)
2023-05-02 18:03:35 +00:00
c.Context().SetBodyStreamWriter(fasthttp.StreamWriter(func(w *bufio.Writer) {
2023-05-02 18:03:35 +00:00
for ev := range responses {
var buf bytes.Buffer
enc := json.NewEncoder(&buf)
enc.Encode(ev)
2023-05-02 18:03:35 +00:00
log.Debug().Msgf("Sending chunk: %s", buf.String())
fmt.Fprintf(w, "data: %v\n", buf.String())
2023-05-02 18:03:35 +00:00
w.Flush()
}
resp := &OpenAIResponse{
Model: input.Model, // we have to return what the user sent here, due to OpenAI spec.
2023-04-29 07:22:09 +00:00
Choices: []Choice{{FinishReason: "stop"}},
}
respData, _ := json.Marshal(resp)
2023-05-02 18:03:35 +00:00
w.WriteString(fmt.Sprintf("data: %s\n\n", respData))
w.WriteString("data: [DONE]\n\n")
w.Flush()
}))
return nil
}
2023-04-29 07:22:09 +00:00
2023-05-21 12:38:25 +00:00
result, err := ComputeChoices(predInput, input, config, o.loader, func(s string, c *[]Choice) {
2023-05-02 18:03:35 +00:00
*c = append(*c, Choice{Message: &Message{Role: "assistant", Content: s}})
}, nil)
if err != nil {
return err
}
resp := &OpenAIResponse{
Model: input.Model, // we have to return what the user sent here, due to OpenAI spec.
Choices: result,
Object: "chat.completion",
}
2023-05-04 15:32:23 +00:00
respData, _ := json.Marshal(resp)
log.Debug().Msgf("Response: %s", respData)
2023-05-02 18:03:35 +00:00
2023-04-29 07:22:09 +00:00
// Return the prediction in the response body
return c.JSON(resp)
}
}
2023-05-21 12:38:25 +00:00
func editEndpoint(cm *ConfigMerger, o *Option) func(c *fiber.Ctx) error {
2023-04-29 07:22:09 +00:00
return func(c *fiber.Ctx) error {
2023-05-21 12:38:25 +00:00
model, input, err := readInput(c, o.loader, true)
if err != nil {
return fmt.Errorf("failed reading parameters from request:%w", err)
}
2023-05-21 12:38:25 +00:00
config, input, err := readConfig(model, input, cm, o.loader, o.debug, o.threads, o.ctxSize, o.f16)
2023-04-29 07:22:09 +00:00
if err != nil {
return fmt.Errorf("failed reading parameters from request:%w", err)
}
log.Debug().Msgf("Parameter Config: %+v", config)
templateFile := config.Model
if config.TemplateConfig.Edit != "" {
templateFile = config.TemplateConfig.Edit
}
var result []Choice
for _, i := range config.InputStrings {
// A model can have a "file.bin.tmpl" file associated with a prompt template prefix
2023-05-21 12:38:25 +00:00
templatedInput, err := o.loader.TemplatePrefix(templateFile, struct {
Input string
Instruction string
}{Input: i})
if err == nil {
i = templatedInput
log.Debug().Msgf("Template found, input modified to: %s", i)
}
2023-04-29 07:22:09 +00:00
2023-05-21 12:38:25 +00:00
r, err := ComputeChoices(i, input, config, o.loader, func(s string, c *[]Choice) {
*c = append(*c, Choice{Text: s})
}, nil)
if err != nil {
return err
}
result = append(result, r...)
2023-04-29 07:22:09 +00:00
}
resp := &OpenAIResponse{
Model: input.Model, // we have to return what the user sent here, due to OpenAI spec.
Choices: result,
Object: "edit",
}
jsonResult, _ := json.Marshal(resp)
log.Debug().Msgf("Response: %s", jsonResult)
// Return the prediction in the response body
return c.JSON(resp)
}
}
// https://platform.openai.com/docs/api-reference/images/create
/*
*
curl http://localhost:8080/v1/images/generations \
-H "Content-Type: application/json" \
-d '{
"prompt": "A cute baby sea otter",
"n": 1,
"size": "512x512"
}'
*
*/
2023-05-21 12:38:25 +00:00
func imageEndpoint(cm *ConfigMerger, o *Option) func(c *fiber.Ctx) error {
return func(c *fiber.Ctx) error {
2023-05-21 12:38:25 +00:00
m, input, err := readInput(c, o.loader, false)
if err != nil {
return fmt.Errorf("failed reading parameters from request:%w", err)
}
if m == "" {
m = model.StableDiffusionBackend
}
log.Debug().Msgf("Loading model: %+v", m)
2023-05-21 12:38:25 +00:00
config, input, err := readConfig(m, input, cm, o.loader, o.debug, 0, 0, false)
if err != nil {
return fmt.Errorf("failed reading parameters from request:%w", err)
}
log.Debug().Msgf("Parameter Config: %+v", config)
// XXX: Only stablediffusion is supported for now
if config.Backend == "" {
config.Backend = model.StableDiffusionBackend
}
sizeParts := strings.Split(input.Size, "x")
if len(sizeParts) != 2 {
return fmt.Errorf("Invalid value for 'size'")
}
width, err := strconv.Atoi(sizeParts[0])
if err != nil {
return fmt.Errorf("Invalid value for 'size'")
}
height, err := strconv.Atoi(sizeParts[1])
if err != nil {
return fmt.Errorf("Invalid value for 'size'")
}
b64JSON := false
if input.ResponseFormat == "b64_json" {
b64JSON = true
}
var result []Item
for _, i := range config.PromptStrings {
2023-05-17 19:01:46 +00:00
n := input.N
if input.N == 0 {
n = 1
}
2023-05-17 19:01:46 +00:00
for j := 0; j < n; j++ {
prompts := strings.Split(i, "|")
positive_prompt := prompts[0]
negative_prompt := ""
if len(prompts) > 1 {
negative_prompt = prompts[1]
}
2023-05-17 19:01:46 +00:00
mode := 0
step := 15
2023-05-17 19:01:46 +00:00
if input.Mode != 0 {
mode = input.Mode
}
2023-05-17 19:01:46 +00:00
if input.Step != 0 {
step = input.Step
}
2023-05-17 19:01:46 +00:00
tempDir := ""
if !b64JSON {
2023-05-21 12:38:25 +00:00
tempDir = o.imageDir
2023-05-17 19:01:46 +00:00
}
// Create a temporary file
outputFile, err := ioutil.TempFile(tempDir, "b64")
if err != nil {
return err
}
outputFile.Close()
output := outputFile.Name() + ".png"
// Rename the temporary file
err = os.Rename(outputFile.Name(), output)
if err != nil {
return err
}
2023-05-17 19:01:46 +00:00
baseURL := c.BaseURL()
2023-05-21 12:38:25 +00:00
fn, err := ImageGeneration(height, width, mode, step, input.Seed, positive_prompt, negative_prompt, output, o.loader, *config)
if err != nil {
return err
}
2023-05-17 19:01:46 +00:00
if err := fn(); err != nil {
return err
}
item := &Item{}
if b64JSON {
defer os.RemoveAll(output)
data, err := os.ReadFile(output)
if err != nil {
return err
}
item.B64JSON = base64.StdEncoding.EncodeToString(data)
} else {
base := filepath.Base(output)
item.URL = baseURL + "/generated-images/" + base
}
2023-05-17 19:01:46 +00:00
result = append(result, *item)
}
}
resp := &OpenAIResponse{
Data: result,
}
jsonResult, _ := json.Marshal(resp)
log.Debug().Msgf("Response: %s", jsonResult)
// Return the prediction in the response body
return c.JSON(resp)
}
}
2023-05-09 09:43:50 +00:00
// https://platform.openai.com/docs/api-reference/audio/create
2023-05-21 12:38:25 +00:00
func transcriptEndpoint(cm *ConfigMerger, o *Option) func(c *fiber.Ctx) error {
2023-05-09 09:43:50 +00:00
return func(c *fiber.Ctx) error {
2023-05-21 12:38:25 +00:00
m, input, err := readInput(c, o.loader, false)
2023-05-09 09:43:50 +00:00
if err != nil {
return fmt.Errorf("failed reading parameters from request:%w", err)
}
2023-05-21 12:38:25 +00:00
config, input, err := readConfig(m, input, cm, o.loader, o.debug, o.threads, o.ctxSize, o.f16)
if err != nil {
return fmt.Errorf("failed reading parameters from request:%w", err)
}
2023-05-09 09:43:50 +00:00
// retrieve the file data from the request
file, err := c.FormFile("file")
if err != nil {
return err
2023-05-09 09:43:50 +00:00
}
f, err := file.Open()
if err != nil {
return err
}
defer f.Close()
2023-05-09 09:43:50 +00:00
dir, err := os.MkdirTemp("", "whisper")
2023-05-09 09:43:50 +00:00
if err != nil {
return err
}
defer os.RemoveAll(dir)
dst := filepath.Join(dir, path.Base(file.Filename))
dstFile, err := os.Create(dst)
if err != nil {
return err
}
if _, err := io.Copy(dstFile, f); err != nil {
log.Debug().Msgf("Audio file copying error %+v - %+v - err %+v", file.Filename, dst, err)
2023-05-09 09:43:50 +00:00
return err
}
log.Debug().Msgf("Audio file copied to: %+v", dst)
2023-05-21 12:38:25 +00:00
whisperModel, err := o.loader.BackendLoader(model.WhisperBackend, config.Model, []llama.ModelOption{}, uint32(config.Threads))
2023-05-11 12:05:07 +00:00
if err != nil {
return err
2023-05-11 12:05:07 +00:00
}
if whisperModel == nil {
return fmt.Errorf("could not load whisper model")
}
w, ok := whisperModel.(whisper.Model)
if !ok {
return fmt.Errorf("loader returned non-whisper object")
}
2023-05-11 14:34:16 +00:00
tr, err := whisperutil.Transcript(w, dst, input.Language, uint(config.Threads))
2023-05-09 09:43:50 +00:00
if err != nil {
return err
2023-05-09 09:43:50 +00:00
}
log.Debug().Msgf("Trascribed: %+v", tr)
// TODO: handle different outputs here
return c.Status(http.StatusOK).JSON(fiber.Map{"text": tr})
}
}
func listModels(loader *model.ModelLoader, cm *ConfigMerger) func(ctx *fiber.Ctx) error {
return func(c *fiber.Ctx) error {
models, err := loader.ListModels()
if err != nil {
return err
}
var mm map[string]interface{} = map[string]interface{}{}
dataModels := []OpenAIModel{}
for _, m := range models {
mm[m] = nil
dataModels = append(dataModels, OpenAIModel{ID: m, Object: "model"})
}
for _, k := range cm.ListConfigs() {
if _, exists := mm[k]; !exists {
dataModels = append(dataModels, OpenAIModel{ID: k, Object: "model"})
}
}
return c.JSON(struct {
Object string `json:"object"`
Data []OpenAIModel `json:"data"`
}{
Object: "list",
Data: dataModels,
})
}
}