code.oscarkilo.com/klex-git

Hash:
86cb636e5aa9eed130ec204c8d94bc82f7902244
Author:
Igor Naverniouk <[email protected]>
Date:
Sun May 18 20:11:12 2025 -0700
Message:
DEBUG
diff --git a/api/api.go b/api/api.go
index 8d7f448..6e2156f 100644
--- a/api/api.go
+++ b/api/api.go
@@ -26,6 +26,9 @@ func NewClient(klexURL, apiKey string) *Client {
}

func (c *Client) call(method, path string, req, res interface{}) error {
+ if b, e := json.MarshalIndent(req, "", " "); e == nil { // DEBUG
+ log.Printf("Request %s %s: %s", method, path, string(b)) // DEBUG
+ } // DEBUG
reqBody, err := json.Marshal(req)
if err != nil {
return fmt.Errorf("Cannot marshal request: %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
if b, e := json.MarshalIndent(req, "", " "); e == nil { // DEBUG
30
log.Printf("Request %s %s: %s", method, path, string(b)) // DEBUG
31
} // DEBUG
29
reqBody, err := json.Marshal(req)
32
reqBody, err := json.Marshal(req)
30
if err != nil {
33
if err != nil {
31
return fmt.Errorf("Cannot marshal request: %v", err)
34
return fmt.Errorf("Cannot marshal request: %v", err)
32
}
35
}
33
reqBytes := bytes.NewBuffer(reqBody)
36
reqBytes := bytes.NewBuffer(reqBody)
34
r, err := http.NewRequest(method, c.KlexURL + path, reqBytes)
37
r, err := http.NewRequest(method, c.KlexURL + path, reqBytes)
35
if err != nil {
38
if err != nil {
36
return fmt.Errorf("In http.NewRequest: %v", err)
39
return fmt.Errorf("In http.NewRequest: %v", err)
37
}
40
}
38
r.Header.Set("Authorization", "Bearer " + c.APIKey)
41
r.Header.Set("Authorization", "Bearer " + c.APIKey)
39
r.Header.Set("Content-Type", "application/json")
42
r.Header.Set("Content-Type", "application/json")
40
resHttp, err := http.DefaultClient.Do(r)
43
resHttp, err := http.DefaultClient.Do(r)
41
if err != nil {
44
if err != nil {
42
return fmt.Errorf("http.DefaultClient.Do: %v", err)
45
return fmt.Errorf("http.DefaultClient.Do: %v", err)
43
}
46
}
44
defer resHttp.Body.Close()
47
defer resHttp.Body.Close()
45
resBody, err := ioutil.ReadAll(resHttp.Body)
48
resBody, err := ioutil.ReadAll(resHttp.Body)
46
if err != nil {
49
if err != nil {
47
return fmt.Errorf("Response error: %v", err)
50
return fmt.Errorf("Response error: %v", err)
48
}
51
}
49
if resHttp.StatusCode != 200 && resHttp.StatusCode != 204 {
52
if resHttp.StatusCode != 200 && resHttp.StatusCode != 204 {
50
return fmt.Errorf("Status %d; response=%s", resHttp.StatusCode, resBody)
53
return fmt.Errorf("Status %d; response=%s", resHttp.StatusCode, resBody)
51
}
54
}
52
if res != nil {
55
if res != nil {
53
if err := json.Unmarshal(resBody, res); err != nil {
56
if err := json.Unmarshal(resBody, res); err != nil {
54
return fmt.Errorf("Bad response %s\nerror=%v", resBody, err)
57
return fmt.Errorf("Bad response %s\nerror=%v", resBody, err)
55
}
58
}
56
}
59
}
57
return nil
60
return nil
58
}
61
}
59
62
60
// F executes a function on one given input.
63
// F executes a function on one given input.
61
func (c *Client) F(f, in string) (string, error) {
64
func (c *Client) F(f, in string) (string, error) {
62
var res FResponse
65
var res FResponse
63
err := c.call("POST", "/f", FRequest{FName: f, In: in}, &res)
66
err := c.call("POST", "/f", FRequest{FName: f, In: in}, &res)
64
if err != nil {
67
if err != nil {
65
return "", err
68
return "", err
66
}
69
}
67
if res.Err != "" {
70
if res.Err != "" {
68
return "", fmt.Errorf(res.Err)
71
return "", fmt.Errorf(res.Err)
69
}
72
}
70
return res.Out, nil
73
return res.Out, nil
71
}
74
}
72
75
73
// Messages executes an LLM function using the Messages API.
76
// Messages executes an LLM function using the Messages API.
74
// Set req.Model to one of the Klex LLM function names.
77
// Set req.Model to one of the Klex LLM function names.
75
func (c *Client) Messages(req MessagesRequest) (*MessagesResponse, error) {
78
func (c *Client) Messages(req MessagesRequest) (*MessagesResponse, error) {
76
f := req.Model
79
f := req.Model
77
req.Model = ""
80
req.Model = ""
78
if f == "" {
81
if f == "" {
79
return nil, fmt.Errorf("MessagesRequest.Model is empty")
82
return nil, fmt.Errorf("MessagesRequest.Model is empty")
80
}
83
}
81
in, err := json.Marshal(req)
84
in, err := json.Marshal(req)
82
if err != nil {
85
if err != nil {
83
return nil, fmt.Errorf("Cannot marshal request: %v", err)
86
return nil, fmt.Errorf("Cannot marshal request: %v", err)
84
}
87
}
85
out, err := c.F(f, string(in))
88
out, err := c.F(f, string(in))
86
if err != nil {
89
if err != nil {
87
return nil, err
90
return nil, err
88
}
91
}
89
var res MessagesResponse
92
var res MessagesResponse
90
err = json.Unmarshal([]byte(out), &res)
93
err = json.Unmarshal([]byte(out), &res)
91
if err != nil {
94
if err != nil {
92
// Instead of failing, treat the whole output as text, and add an error.
95
// Instead of failing, treat the whole output as text, and add an error.
93
// Let the caller figure this out.
96
// Let the caller figure this out.
94
res.Error = &ErrorResponse{
97
res.Error = &ErrorResponse{
95
Type: "response-json",
98
Type: "response-json",
96
Message: err.Error(),
99
Message: err.Error(),
97
}
100
}
98
res.Content = []ContentBlock{{Type: "text", Text: out}}
101
res.Content = []ContentBlock{{Type: "text", Text: out}}
99
}
102
}
100
return &res, nil
103
return &res, nil
101
}
104
}
102
105
103
// Embed returns semantic embedding vectors for the given text.
106
// Embed returns semantic embedding vectors for the given text.
104
func (c *Client) Embed(req EmbedRequest) ([][]float32, error) {
107
func (c *Client) Embed(req EmbedRequest) ([][]float32, error) {
105
url := fmt.Sprintf(
108
url := fmt.Sprintf(
106
"/embed/do?model=%s&dims=%d&path=%t",
109
"/embed/do?model=%s&dims=%d&path=%t",
107
req.Model, req.Dims, req.FullPath,
110
req.Model, req.Dims, req.FullPath,
108
)
111
)
109
var resp [][]float32
112
var resp [][]float32
110
err := c.call("POST", url, req.Text, &resp)
113
err := c.call("POST", url, req.Text, &resp)
111
return resp, err
114
return resp, err
112
}
115
}
113
116
114
// NewDataset creates a new dataset or updates an existing one.
117
// NewDataset creates a new dataset or updates an existing one.
115
// This is the simplest way, meant for datasets smaller than ~1GB.
118
// This is the simplest way, meant for datasets smaller than ~1GB.
116
func (c *Client) NewDataset(name string, data map[string]string) error {
119
func (c *Client) NewDataset(name string, data map[string]string) error {
117
// TODO: this loses key names; get rid of this API.
120
// TODO: this loses key names; get rid of this API.
118
req := NewDatasetRequest{Name: name, Data: nil}
121
req := NewDatasetRequest{Name: name, Data: nil}
119
keys := make([]string, 0, len(data))
122
keys := make([]string, 0, len(data))
120
for k := range data {
123
for k := range data {
121
keys = append(keys, k)
124
keys = append(keys, k)
122
}
125
}
123
sort.Strings(keys)
126
sort.Strings(keys)
124
for _, k := range keys {
127
for _, k := range keys {
125
req.Data = append(req.Data, data[k])
128
req.Data = append(req.Data, data[k])
126
}
129
}
127
130
128
var res NewDatasetResponse
131
var res NewDatasetResponse
129
err := c.call("POST", "/datasets/new", req, &res)
132
err := c.call("POST", "/datasets/new", req, &res)
130
if err != nil {
133
if err != nil {
131
return fmt.Errorf("Error POSTing to /datasets/new: %v", err)
134
return fmt.Errorf("Error POSTing to /datasets/new: %v", err)
132
}
135
}
133
if res.Name != name || res.Size != len(data) {
136
if res.Name != name || res.Size != len(data) {
134
pretty, _ := json.MarshalIndent(res, "", " ")
137
pretty, _ := json.MarshalIndent(res, "", " ")
135
return fmt.Errorf("Unexpected response from /datasets/new: %s", pretty)
138
return fmt.Errorf("Unexpected response from /datasets/new: %s", pretty)
136
}
139
}
137
return nil
140
return nil
138
}
141
}
139
142
140
// BeginNewDataset starts a new dataset upload using the v2 API.
143
// BeginNewDataset starts a new dataset upload using the v2 API.
141
// Returns the version key to use in UploadKv() and EndNewDataset().
144
// Returns the version key to use in UploadKv() and EndNewDataset().
142
// Keep the key secret until EndNewDataset() returns successfully.
145
// Keep the key secret until EndNewDataset() returns successfully.
143
func (c *Client) BeginNewDataset(name string) (string, error) {
146
func (c *Client) BeginNewDataset(name string) (string, error) {
144
req := BeginNewDatasetRequest{Name: name}
147
req := BeginNewDatasetRequest{Name: name}
145
var res BeginNewDatasetResponse
148
var res BeginNewDatasetResponse
146
err := c.call("POST", "/datasets/begin_new", req, &res)
149
err := c.call("POST", "/datasets/begin_new", req, &res)
147
if err != nil {
150
if err != nil {
148
return "", fmt.Errorf("Error POSTing to /datasets/begin_new: %v", err)
151
return "", fmt.Errorf("Error POSTing to /datasets/begin_new: %v", err)
149
}
152
}
150
return res.VersionKey, nil
153
return res.VersionKey, nil
151
}
154
}
152
155
153
// UploadKv uploads more key-value pairs of the dataset being created.
156
// UploadKv uploads more key-value pairs of the dataset being created.
154
func (c *Client) UploadKV(versionKey string, records []KV) error {
157
func (c *Client) UploadKV(versionKey string, records []KV) error {
155
req := UploadKVRequest{VersionKey: versionKey, Records: records}
158
req := UploadKVRequest{VersionKey: versionKey, Records: records}
156
err := c.call("POST", "/datasets/upload_kv", req, nil)
159
err := c.call("POST", "/datasets/upload_kv", req, nil)
157
if err != nil {
160
if err != nil {
158
return fmt.Errorf("Error POSTing to /datasets/upload_kv: %v", err)
161
return fmt.Errorf("Error POSTing to /datasets/upload_kv: %v", err)
159
}
162
}
160
return nil
163
return nil
161
}
164
}
162
165
163
// EndNewDataset commits the dataset being created.
166
// EndNewDataset commits the dataset being created.
164
func (c *Client) EndNewDataset(name, version_key string, size int) error {
167
func (c *Client) EndNewDataset(name, version_key string, size int) error {
165
req := EndNewDatasetRequest{Name: name, VersionKey: version_key, Size: size}
168
req := EndNewDatasetRequest{Name: name, VersionKey: version_key, Size: size}
166
err := c.call("POST", "/datasets/end_new", req, nil)
169
err := c.call("POST", "/datasets/end_new", req, nil)
167
if err != nil {
170
if err != nil {
168
return fmt.Errorf("Error POSTing to /datasets/end_new: %v", err)
171
return fmt.Errorf("Error POSTing to /datasets/end_new: %v", err)
169
}
172
}
170
return nil
173
return nil
171
}
174
}