code.oscarkilo.com/klex-git

Hash:
fb2e6ad3e6cdc12f6a3ecc6549b696c76bb8f712
Author:
Igor Naverniouk <[email protected]>
Date:
Sun May 18 20:03:14 2025 -0700
Message:
renaming
diff --git a/api/api.go b/api/api.go
index f06f49f..8d7f448 100644
--- a/api/api.go
+++ b/api/api.go
@@ -104,7 +104,7 @@ func (c *Client) Messages(req MessagesRequest) (*MessagesResponse, error) {
func (c *Client) Embed(req EmbedRequest) ([][]float32, error) {
url := fmt.Sprintf(
"/embed/do?model=%s&dims=%d&path=%t",
- req.Model, req.Dims, req.WholePath,
+ req.Model, req.Dims, req.FullPath,
)
var resp [][]float32
err := c.call("POST", url, req.Text, &resp)
diff --git a/api/embed.go b/api/embed.go
index 93c7ae7..a65d6ef 100644
--- a/api/embed.go
+++ b/api/embed.go
@@ -13,7 +13,7 @@ type EmbedRequest struct {
// A good chioce is 1536 for openai:text-embedding-3-small.
Dims int `json:"dims"`

- // WholePath returns a sequence of vectors, one per prefix of Text.
+ // FullPath returns a sequence of vectors, one per prefix of Text.
// Instead of the usual array of numbers, you'll get a 2D array.
- WholePath bool `json:"whole_path"`
+ FullPath bool `json:"whole_path"`
}
diff --git a/embed/main.go b/embed/main.go
index 4b4dd05..3a5929b 100644
--- a/embed/main.go
+++ b/embed/main.go
@@ -42,7 +42,7 @@ func main() {
Text: string(sin),
Model: *model,
Dims: *dims,
- WholePath: *whole_path,
+ FullPath: *whole_path,
})
if err != nil {
log.Fatalf("Failed to call Embed: %v", err)
a/api/api.go
b/api/api.go
1
package api
1
package api
2
2
3
// This file is for Golang clients of Klex.
3
// This file is for Golang clients of Klex.
4
4
5
import (
5
import (
6
"bytes"
6
"bytes"
7
"encoding/json"
7
"encoding/json"
8
"fmt"
8
"fmt"
9
"io/ioutil"
9
"io/ioutil"
10
"log"
10
"log"
11
"net/http"
11
"net/http"
12
"sort"
12
"sort"
13
)
13
)
14
14
15
type Client struct {
15
type Client struct {
16
KlexURL string
16
KlexURL string
17
APIKey string
17
APIKey string
18
}
18
}
19
19
20
func NewClient(klexURL, apiKey string) *Client {
20
func NewClient(klexURL, apiKey string) *Client {
21
if klexURL == "" || apiKey == "" {
21
if klexURL == "" || apiKey == "" {
22
log.Printf("NewClient: missing klexURL or apiKey")
22
log.Printf("NewClient: missing klexURL or apiKey")
23
return nil
23
return nil
24
}
24
}
25
return &Client{klexURL, apiKey}
25
return &Client{klexURL, apiKey}
26
}
26
}
27
27
28
func (c *Client) call(method, path string, req, res interface{}) error {
28
func (c *Client) call(method, path string, req, res interface{}) error {
29
reqBody, err := json.Marshal(req)
29
reqBody, err := json.Marshal(req)
30
if err != nil {
30
if err != nil {
31
return fmt.Errorf("Cannot marshal request: %v", err)
31
return fmt.Errorf("Cannot marshal request: %v", err)
32
}
32
}
33
reqBytes := bytes.NewBuffer(reqBody)
33
reqBytes := bytes.NewBuffer(reqBody)
34
r, err := http.NewRequest(method, c.KlexURL + path, reqBytes)
34
r, err := http.NewRequest(method, c.KlexURL + path, reqBytes)
35
if err != nil {
35
if err != nil {
36
return fmt.Errorf("In http.NewRequest: %v", err)
36
return fmt.Errorf("In http.NewRequest: %v", err)
37
}
37
}
38
r.Header.Set("Authorization", "Bearer " + c.APIKey)
38
r.Header.Set("Authorization", "Bearer " + c.APIKey)
39
r.Header.Set("Content-Type", "application/json")
39
r.Header.Set("Content-Type", "application/json")
40
resHttp, err := http.DefaultClient.Do(r)
40
resHttp, err := http.DefaultClient.Do(r)
41
if err != nil {
41
if err != nil {
42
return fmt.Errorf("http.DefaultClient.Do: %v", err)
42
return fmt.Errorf("http.DefaultClient.Do: %v", err)
43
}
43
}
44
defer resHttp.Body.Close()
44
defer resHttp.Body.Close()
45
resBody, err := ioutil.ReadAll(resHttp.Body)
45
resBody, err := ioutil.ReadAll(resHttp.Body)
46
if err != nil {
46
if err != nil {
47
return fmt.Errorf("Response error: %v", err)
47
return fmt.Errorf("Response error: %v", err)
48
}
48
}
49
if resHttp.StatusCode != 200 && resHttp.StatusCode != 204 {
49
if resHttp.StatusCode != 200 && resHttp.StatusCode != 204 {
50
return fmt.Errorf("Status %d; response=%s", resHttp.StatusCode, resBody)
50
return fmt.Errorf("Status %d; response=%s", resHttp.StatusCode, resBody)
51
}
51
}
52
if res != nil {
52
if res != nil {
53
if err := json.Unmarshal(resBody, res); err != nil {
53
if err := json.Unmarshal(resBody, res); err != nil {
54
return fmt.Errorf("Bad response %s\nerror=%v", resBody, err)
54
return fmt.Errorf("Bad response %s\nerror=%v", resBody, err)
55
}
55
}
56
}
56
}
57
return nil
57
return nil
58
}
58
}
59
59
60
// F executes a function on one given input.
60
// F executes a function on one given input.
61
func (c *Client) F(f, in string) (string, error) {
61
func (c *Client) F(f, in string) (string, error) {
62
var res FResponse
62
var res FResponse
63
err := c.call("POST", "/f", FRequest{FName: f, In: in}, &res)
63
err := c.call("POST", "/f", FRequest{FName: f, In: in}, &res)
64
if err != nil {
64
if err != nil {
65
return "", err
65
return "", err
66
}
66
}
67
if res.Err != "" {
67
if res.Err != "" {
68
return "", fmt.Errorf(res.Err)
68
return "", fmt.Errorf(res.Err)
69
}
69
}
70
return res.Out, nil
70
return res.Out, nil
71
}
71
}
72
72
73
// Messages executes an LLM function using the Messages API.
73
// Messages executes an LLM function using the Messages API.
74
// Set req.Model to one of the Klex LLM function names.
74
// Set req.Model to one of the Klex LLM function names.
75
func (c *Client) Messages(req MessagesRequest) (*MessagesResponse, error) {
75
func (c *Client) Messages(req MessagesRequest) (*MessagesResponse, error) {
76
f := req.Model
76
f := req.Model
77
req.Model = ""
77
req.Model = ""
78
if f == "" {
78
if f == "" {
79
return nil, fmt.Errorf("MessagesRequest.Model is empty")
79
return nil, fmt.Errorf("MessagesRequest.Model is empty")
80
}
80
}
81
in, err := json.Marshal(req)
81
in, err := json.Marshal(req)
82
if err != nil {
82
if err != nil {
83
return nil, fmt.Errorf("Cannot marshal request: %v", err)
83
return nil, fmt.Errorf("Cannot marshal request: %v", err)
84
}
84
}
85
out, err := c.F(f, string(in))
85
out, err := c.F(f, string(in))
86
if err != nil {
86
if err != nil {
87
return nil, err
87
return nil, err
88
}
88
}
89
var res MessagesResponse
89
var res MessagesResponse
90
err = json.Unmarshal([]byte(out), &res)
90
err = json.Unmarshal([]byte(out), &res)
91
if err != nil {
91
if err != nil {
92
// Instead of failing, treat the whole output as text, and add an error.
92
// Instead of failing, treat the whole output as text, and add an error.
93
// Let the caller figure this out.
93
// Let the caller figure this out.
94
res.Error = &ErrorResponse{
94
res.Error = &ErrorResponse{
95
Type: "response-json",
95
Type: "response-json",
96
Message: err.Error(),
96
Message: err.Error(),
97
}
97
}
98
res.Content = []ContentBlock{{Type: "text", Text: out}}
98
res.Content = []ContentBlock{{Type: "text", Text: out}}
99
}
99
}
100
return &res, nil
100
return &res, nil
101
}
101
}
102
102
103
// Embed returns semantic embedding vectors for the given text.
103
// Embed returns semantic embedding vectors for the given text.
104
func (c *Client) Embed(req EmbedRequest) ([][]float32, error) {
104
func (c *Client) Embed(req EmbedRequest) ([][]float32, error) {
105
url := fmt.Sprintf(
105
url := fmt.Sprintf(
106
"/embed/do?model=%s&dims=%d&path=%t",
106
"/embed/do?model=%s&dims=%d&path=%t",
107
req.Model, req.Dims, req.WholePath,
107
req.Model, req.Dims, req.FullPath,
108
)
108
)
109
var resp [][]float32
109
var resp [][]float32
110
err := c.call("POST", url, req.Text, &resp)
110
err := c.call("POST", url, req.Text, &resp)
111
return resp, err
111
return resp, err
112
}
112
}
113
113
114
// NewDataset creates a new dataset or updates an existing one.
114
// NewDataset creates a new dataset or updates an existing one.
115
// This is the simplest way, meant for datasets smaller than ~1GB.
115
// This is the simplest way, meant for datasets smaller than ~1GB.
116
func (c *Client) NewDataset(name string, data map[string]string) error {
116
func (c *Client) NewDataset(name string, data map[string]string) error {
117
// TODO: this loses key names; get rid of this API.
117
// TODO: this loses key names; get rid of this API.
118
req := NewDatasetRequest{Name: name, Data: nil}
118
req := NewDatasetRequest{Name: name, Data: nil}
119
keys := make([]string, 0, len(data))
119
keys := make([]string, 0, len(data))
120
for k := range data {
120
for k := range data {
121
keys = append(keys, k)
121
keys = append(keys, k)
122
}
122
}
123
sort.Strings(keys)
123
sort.Strings(keys)
124
for _, k := range keys {
124
for _, k := range keys {
125
req.Data = append(req.Data, data[k])
125
req.Data = append(req.Data, data[k])
126
}
126
}
127
127
128
var res NewDatasetResponse
128
var res NewDatasetResponse
129
err := c.call("POST", "/datasets/new", req, &res)
129
err := c.call("POST", "/datasets/new", req, &res)
130
if err != nil {
130
if err != nil {
131
return fmt.Errorf("Error POSTing to /datasets/new: %v", err)
131
return fmt.Errorf("Error POSTing to /datasets/new: %v", err)
132
}
132
}
133
if res.Name != name || res.Size != len(data) {
133
if res.Name != name || res.Size != len(data) {
134
pretty, _ := json.MarshalIndent(res, "", " ")
134
pretty, _ := json.MarshalIndent(res, "", " ")
135
return fmt.Errorf("Unexpected response from /datasets/new: %s", pretty)
135
return fmt.Errorf("Unexpected response from /datasets/new: %s", pretty)
136
}
136
}
137
return nil
137
return nil
138
}
138
}
139
139
140
// BeginNewDataset starts a new dataset upload using the v2 API.
140
// BeginNewDataset starts a new dataset upload using the v2 API.
141
// Returns the version key to use in UploadKv() and EndNewDataset().
141
// Returns the version key to use in UploadKv() and EndNewDataset().
142
// Keep the key secret until EndNewDataset() returns successfully.
142
// Keep the key secret until EndNewDataset() returns successfully.
143
func (c *Client) BeginNewDataset(name string) (string, error) {
143
func (c *Client) BeginNewDataset(name string) (string, error) {
144
req := BeginNewDatasetRequest{Name: name}
144
req := BeginNewDatasetRequest{Name: name}
145
var res BeginNewDatasetResponse
145
var res BeginNewDatasetResponse
146
err := c.call("POST", "/datasets/begin_new", req, &res)
146
err := c.call("POST", "/datasets/begin_new", req, &res)
147
if err != nil {
147
if err != nil {
148
return "", fmt.Errorf("Error POSTing to /datasets/begin_new: %v", err)
148
return "", fmt.Errorf("Error POSTing to /datasets/begin_new: %v", err)
149
}
149
}
150
return res.VersionKey, nil
150
return res.VersionKey, nil
151
}
151
}
152
152
153
// UploadKv uploads more key-value pairs of the dataset being created.
153
// UploadKv uploads more key-value pairs of the dataset being created.
154
func (c *Client) UploadKV(versionKey string, records []KV) error {
154
func (c *Client) UploadKV(versionKey string, records []KV) error {
155
req := UploadKVRequest{VersionKey: versionKey, Records: records}
155
req := UploadKVRequest{VersionKey: versionKey, Records: records}
156
err := c.call("POST", "/datasets/upload_kv", req, nil)
156
err := c.call("POST", "/datasets/upload_kv", req, nil)
157
if err != nil {
157
if err != nil {
158
return fmt.Errorf("Error POSTing to /datasets/upload_kv: %v", err)
158
return fmt.Errorf("Error POSTing to /datasets/upload_kv: %v", err)
159
}
159
}
160
return nil
160
return nil
161
}
161
}
162
162
163
// EndNewDataset commits the dataset being created.
163
// EndNewDataset commits the dataset being created.
164
func (c *Client) EndNewDataset(name, version_key string, size int) error {
164
func (c *Client) EndNewDataset(name, version_key string, size int) error {
165
req := EndNewDatasetRequest{Name: name, VersionKey: version_key, Size: size}
165
req := EndNewDatasetRequest{Name: name, VersionKey: version_key, Size: size}
166
err := c.call("POST", "/datasets/end_new", req, nil)
166
err := c.call("POST", "/datasets/end_new", req, nil)
167
if err != nil {
167
if err != nil {
168
return fmt.Errorf("Error POSTing to /datasets/end_new: %v", err)
168
return fmt.Errorf("Error POSTing to /datasets/end_new: %v", err)
169
}
169
}
170
return nil
170
return nil
171
}
171
}
a/api/embed.go
b/api/embed.go
1
package api
1
package api
2
2
3
type EmbedRequest struct {
3
type EmbedRequest struct {
4
// Text should be shorter than ~8000 tokens.
4
// Text should be shorter than ~8000 tokens.
5
Text string `json:"text"`
5
Text string `json:"text"`
6
6
7
// Model is an embedding model name.
7
// Model is an embedding model name.
8
// These are hard-coded in //funky/builtins.
8
// These are hard-coded in //funky/builtins.
9
// A good choice is "openai:text-embedding-3-small".
9
// A good choice is "openai:text-embedding-3-small".
10
Model string `json:"model"`
10
Model string `json:"model"`
11
11
12
// Dims is the number of vector dimensions to return.
12
// Dims is the number of vector dimensions to return.
13
// A good chioce is 1536 for openai:text-embedding-3-small.
13
// A good chioce is 1536 for openai:text-embedding-3-small.
14
Dims int `json:"dims"`
14
Dims int `json:"dims"`
15
15
16
// WholePath returns a sequence of vectors, one per prefix of Text.
16
// FullPath returns a sequence of vectors, one per prefix of Text.
17
// Instead of the usual array of numbers, you'll get a 2D array.
17
// Instead of the usual array of numbers, you'll get a 2D array.
18
WholePath bool `json:"whole_path"`
18
FullPath bool `json:"whole_path"`
19
}
19
}
a/embed/main.go
b/embed/main.go
1
package main
1
package main
2
2
3
// This binary converts text into embedding vecors.
3
// This binary converts text into embedding vecors.
4
4
5
//import "encoding/json"
5
//import "encoding/json"
6
import "flag"
6
import "flag"
7
import "fmt"
7
import "fmt"
8
import "io/ioutil"
8
import "io/ioutil"
9
import "log"
9
import "log"
10
import "os"
10
import "os"
11
//import "sync"
11
//import "sync"
12
12
13
import "oscarkilo.com/klex-git/api"
13
import "oscarkilo.com/klex-git/api"
14
import "oscarkilo.com/klex-git/config"
14
import "oscarkilo.com/klex-git/config"
15
//import "oscarkilo.com/klex-git/util"
15
//import "oscarkilo.com/klex-git/util"
16
16
17
var model = flag.String("model", "openai:text-embedding-3-small", "")
17
var model = flag.String("model", "openai:text-embedding-3-small", "")
18
var dims = flag.Int("dims", 1536, "Number of vector dimensions to return")
18
var dims = flag.Int("dims", 1536, "Number of vector dimensions to return")
19
var whole_path = flag.Bool("whole_path", false, "Returns a list of vectors")
19
var whole_path = flag.Bool("whole_path", false, "Returns a list of vectors")
20
20
21
func main() {
21
func main() {
22
flag.Parse()
22
flag.Parse()
23
23
24
// Find the API keys and configure a Klex client.
24
// Find the API keys and configure a Klex client.
25
config, err := config.ReadConfig()
25
config, err := config.ReadConfig()
26
if err != nil {
26
if err != nil {
27
log.Fatalf("Failed to read config: %v", err)
27
log.Fatalf("Failed to read config: %v", err)
28
}
28
}
29
client := api.NewClient(config.KlexUrl, config.ApiKey)
29
client := api.NewClient(config.KlexUrl, config.ApiKey)
30
if client == nil {
30
if client == nil {
31
log.Fatalf("Failed to create Klex client")
31
log.Fatalf("Failed to create Klex client")
32
}
32
}
33
33
34
// Read stdin as text.
34
// Read stdin as text.
35
sin, err := ioutil.ReadAll(os.Stdin)
35
sin, err := ioutil.ReadAll(os.Stdin)
36
if err != nil {
36
if err != nil {
37
log.Fatalf("Failed to read stdin: %v", err)
37
log.Fatalf("Failed to read stdin: %v", err)
38
}
38
}
39
//text := []string{string(sin)}
39
//text := []string{string(sin)}
40
40
41
vectors, err := client.Embed(api.EmbedRequest{
41
vectors, err := client.Embed(api.EmbedRequest{
42
Text: string(sin),
42
Text: string(sin),
43
Model: *model,
43
Model: *model,
44
Dims: *dims,
44
Dims: *dims,
45
WholePath: *whole_path,
45
FullPath: *whole_path,
46
})
46
})
47
if err != nil {
47
if err != nil {
48
log.Fatalf("Failed to call Embed: %v", err)
48
log.Fatalf("Failed to call Embed: %v", err)
49
}
49
}
50
50
51
/*
51
/*
52
if *whole_path {
52
if *whole_path {
53
text = util.SplitByWord(text[0])
53
text = util.SplitByWord(text[0])
54
}
54
}
55
55
56
f_name := fmt.Sprintf("embed-%s@%d", *model, *dims)
56
f_name := fmt.Sprintf("embed-%s@%d", *model, *dims)
57
vectors := make([][]float32, len(text))
57
vectors := make([][]float32, len(text))
58
wg := sync.WaitGroup{}
58
wg := sync.WaitGroup{}
59
for i := range text {
59
for i := range text {
60
wg.Add(1)
60
wg.Add(1)
61
go func(i int) {
61
go func(i int) {
62
json_vector, err := client.F(f_name, text[i])
62
json_vector, err := client.F(f_name, text[i])
63
if err != nil {
63
if err != nil {
64
log.Fatalf("Failed to call F: %v", err)
64
log.Fatalf("Failed to call F: %v", err)
65
}
65
}
66
err = json.Unmarshal([]byte(json_vector), &vectors[i])
66
err = json.Unmarshal([]byte(json_vector), &vectors[i])
67
if err != nil {
67
if err != nil {
68
log.Fatalf("Failed to parse vector: %v", err)
68
log.Fatalf("Failed to parse vector: %v", err)
69
}
69
}
70
wg.Done()
70
wg.Done()
71
}(i)
71
}(i)
72
}
72
}
73
wg.Wait()
73
wg.Wait()
74
*/
74
*/
75
75
76
for _, vector := range vectors {
76
for _, vector := range vectors {
77
for i, w := range vector {
77
for i, w := range vector {
78
if i > 0 {
78
if i > 0 {
79
fmt.Printf(" ")
79
fmt.Printf(" ")
80
}
80
}
81
fmt.Printf("%g", w)
81
fmt.Printf("%g", w)
82
}
82
}
83
fmt.Printf("\n")
83
fmt.Printf("\n")
84
}
84
}
85
}
85
}