Using Golang for AI

1
go mod init github.com/jdortiz/goai

1
package main
2
3
func main() {
4
}

1
type App struct {
2
}

1
func (app App) Start() error {
2
        const serverAddr string = "0.0.0.0:3001"
3
        log.Printf("Starting HTTP server: %s\n", serverAddr)
4
5
        return http.ListenAndServe(serverAddr, nil)
6
}

1
app := App{}
2
log.Fatal(app.Start())

1
func (app App) imageSearch(w http.ResponseWriter, r *http.Request) {
2
     log.Println("Image search invoked")
3
}

1
http.HandleFunc("POST /api/search", app.imageSearch)

1
curl -IX POST localhost:3001/api/search

1
type CelebMatchRequest struct {
2
        Image64 string `json:"img"`
3
}

1
// Deserialize request
2
var imgReq CelebMatchRequest
3
err := json.NewDecoder(r.Body).Decode(&imgReq)
4
if err != nil {
5
        log.Println("ERR: parsing json data", err)
6
        http.Error(w, err.Error(), http.StatusBadRequest)
7
        return
8
}

1
// Split image into metadata and data
2
imgParts := strings.Split(imgReq.Image64, ",")
3
parts := len(imgParts)
4
if parts != 2 {
5
        log.Printf("ERR: expecting metadata and data. Got %d parts\n", parts)
6
        http.Error(w, fmt.Sprintf("expecting metadata and data. Got %d parts", parts), http.StatusBadRequest)
7
        return
8
}

1
// Receives a base64 encoded image
2
func standardizeImage(imageB64 string) (*string, error) {
3
}

1
// Get the base64 decoder as an io.Reader and use it to decode the image from the data
2
b64Decoder := base64.NewDecoder(base64.StdEncoding, strings.NewReader(imageB64))
3
origImg, _, err := image.Decode(b64Decoder)
4
if err != nil {
5
        return nil, fmt.Errorf("standardizing image failed: %w", err)
6
}

1
// Resize to 800x600
2
resizedImg := image.NewRGBA(image.Rect(0, 0, 800, 600))
3
draw.NearestNeighbor.Scale(resizedImg, resizedImg.Rect, origImg, origImg.Bounds(), draw.Over, nil)

1
// Reencode the image to JPEG format with Q=85
2
var jpegToSend bytes.Buffer
3
// Encode the image into the buffer
4
if err = jpeg.Encode(&jpegToSend, resizedImg, &jpeg.Options{Quality: 85}); err != nil {
5
        return nil, fmt.Errorf("standardizing image failed: %w", err)
6
}
7
// Re-encode to base64
8
stdImgB64 := base64.StdEncoding.EncodeToString(jpegToSend.Bytes())
9
return &stdImgB64, nil

1
// Decode image from base 64, resize image to 800x600 with Q=85, and re-encode to base64
2
stdImage, err := standardizeImage(imgParts[1])
3
if err != nil {
4
        log.Println("ERR:", err)
5
        http.Error(w, "Error standardizing image", http.StatusInternalServerError)
6
        return
7
}

1
go get golang.org/x/image/draw

1
go get github.com/aws/aws-sdk-go-v2/config
2
go get github.com/aws/aws-sdk-go-v2/service/bedrockruntime

1
configur  *aws.Config

1
func connectToAWS(ctx context.Context) (*aws.Config, error) {
2
        const dfltRegion string = "us-east-1"
3
        const credAccount string = "your-account-name"
4
        // Load the Shared AWS Configuration (~/.aws/config)
5
        cfg, err := config.LoadDefaultConfig(ctx,
6
                config.WithSharedConfigProfile(credAccount), // this must be the name of the profile in ~/.aws/config and ~/.aws/credentials
7
                config.WithRegion(dfltRegion),
8
        )
9
        return &cfg, err
10
}

1
func NewApp(ctx context.Context) (*App, error) {
2
        cfg, err := connectToAWS(ctx)
3
        if err != nil {
4
                log.Println("ERR: Couldn't load default configuration. Have you set up your AWS account?", err)
5
                return nil, err
6
        }
7
8
        return &App{
9
                config:  cfg,
10
        }, nil
11
}

1
bedrock *bedrockruntime.Client

1
// Initialize bedrock client
2
bedrockClient := bedrockruntime.NewFromConfig(*cfg)
3
4
 return &App{
5
         config:  cfg,
6
         bedrock: bedrockClient,
7
 }, nil

1
ctx := context.Background()
2
app, err := NewApp(ctx)
3
if err != nil {
4
        panic(err)
5
}

1
// Prepare request to titan-embed-img-v1
2
func (app App) computeImageEmbedding(ctx context.Context, image string) ([]float64, error) {
3
}

1
const titanEmbedImgV1ModelId string = "amazon.titan-embed-image-v1"

1
type EmbeddingConfig struct {
2
        OutputEmbeddingLength int `json:"outputEmbeddingLength"`
3
}
4
5
type BedrockRequest struct {
6
        InputImage      string          `json:"inputImage"`
7
        EmbeddingConfig EmbeddingConfig `json:"embeddingConfig"`
8
        InputText       *string         `json:"inputText,omitempty"`
9
}

1
// Prepare the request to bedrock
2
payload := BedrockRequest{
3
        InputImage: image,
4
        EmbeddingConfig: EmbeddingConfig{
5
                OutputEmbeddingLength: 1024,
6
        },
7
        InputText: nil,
8
}

1
bedrockBody, err := json.Marshal(payload)
2
if err != nil {
3
        return nil, fmt.Errorf("failed to get embedding from bedrock: %w", err)
4
}

1
bedrockReq := bedrockruntime.InvokeModelInput{
2
        ModelId:     aws.String(titanEmbedImgV1ModelId),
3
        Body:        bedrockBody,
4
        ContentType: aws.String(contentTypeJson),
5
}

1
const contentTypeJson = "application/json"

1
// Invoke model to obtain embedding for the image
2
embeddingResp, err := app.bedrock.InvokeModel(ctx, &bedrockReq)
3
if err != nil {
4
        return nil, fmt.Errorf("failed to get embedding from bedrock: %w", err)
5
}

1
go get github.com/tidwall/gjson

1
result := gjson.GetBytes(embeddingResp.Body, "embedding")
2
var embedding []float64
3
result.ForEach(func(key, value gjson.Result) bool {
4
        embedding = append(embedding, value.Float())
5
        return true
6
})
7
8
return embedding, nil

1
// Compute the embedding using titan-embed-image-v1
2
embedding, err := app.computeImageEmbedding(r.Context(), *stdImage)
3
if err != nil {
4
        log.Println("ERR:", err)
5
        http.Error(w, "Error computing embedding", http.StatusInternalServerError)
6
        return
7
}

1
go get github.com/joho/godotenv

1
var uri string
2
err := godotenv.Load()
3
if err != nil {
4
        log.Fatal("Unable to load .env file")
5
}
6
if uri = os.Getenv("MONGODB_URI"); uri == "" {
7
        log.Fatal("You must set your 'MONGODB_URI' environment variable. See\n\t https://docs.mongodb.com/drivers/go/current/usage-examples/")
8
}

1
go get go.mongodb.org/mongo-driver/v2

1
client *mongo.Client

1
func newDBClient(uri string) (*mongo.Client, error) {
2
        // Use the SetServerAPIOptions() method to set the Stable API version to 1
3
        serverAPI := options.ServerAPI(options.ServerAPIVersion1)
4
        opts := options.Client().ApplyURI(uri).SetServerAPIOptions(serverAPI)
5
        // Create a new client and connect to the server
6
        client, err := mongo.Connect(opts)
7
        if err != nil {
8
                return nil, err
9
        }
10
11
        return client, nil
12
}

1
func NewApp(ctx context.Context, uri string) (*App, error) {

1
app, err := NewApp(ctx, uri)

1
client, err := newDBClient(uri)
2
if err != nil {
3
        log.Println("ERR: connecting to MongoDB cluster:", err)
4
        return nil, err
5
}
6
7
return &App{
8
            client:  client,
9
            config:  cfg,
10
            bedrock: bedrockClient,
11
}, nil

1
func (app *App) Close() {
2
        if err := app.client.Disconnect(context.Background()); err != nil {
3
                panic(err)
4
        }
5
}

1
defer func() {
2
        app.Close()
3
}()

1
func (app App) findSimilarImages(ctx context.Context, embedding []float64) ([]string, error) {
2
}

1
// Get celeb image collection
2
imgCollection := app.client.Database("celebrity_matcher").Collection("celeb_images")

1
// Aggregation pipeline to get the 3 closest images to the given embedding.
2
vectorSchStage := bson.D{{"$vectorSearch", bson.D{{"index", "vector_index"},
3
        {"path", "embeddings"},
4
        {"queryVector", embedding},
5
        {"numCandidates", 15},
6
        {"limit", 3}}}}

1
projectStage := bson.D{{"$project", bson.D{{"image", 1}}}}

1
pipeline := mongo.Pipeline{vectorSchStage, projectStage}

1
// Make query
2
imgCursor, err := imgCollection.Aggregate(ctx, pipeline)
3
if err != nil {
4
        return nil, fmt.Errorf("failed to get similar images from the database: %w", err)
5
}

1
// Get all the result using the cursor
2
similarImgs := []struct {
3
        Id    bson.ObjectID `bson:"_id,omitempty"`
4
        Image string        `bson:"image"`
5
}{}
6
if err = imgCursor.All(ctx, &similarImgs); err != nil {
7
        return nil, fmt.Errorf("failed to get similar images from the database: %w", err)
8
}

1
// Return just the standardized images in an array
2
var images []string
3
var stdImage *string
4
for _, item := range similarImgs {
5
        stdImage, err = standardizeImage(item.Image)
6
        if err != nil {
7
                return nil, fmt.Errorf("failed to standardize similar images: %w", err)
8
        }
9
        images = append(images, *stdImage)
10
}
11
return images, nil

1
// Find similar images using vector search in MongoDB
2
images, err := app.findSimilarImages(r.Context(), embedding)
3
if err != nil {
4
        log.Println("ERR:", err)
5
        http.Error(w, "Error getting similar images", http.StatusInternalServerError)
6
        return
7
}

1
// https://docs.aws.amazon.com/bedrock/latest/userguide/model-parameters-anthropic-claude-messages.html
2
func (app App) getImageSimilaritiesDescription(ctx context.Context, imgB64 string, similarImgB64 []string) (*string, error) {
3
}

1
const claude3SonnetV1ModelId string = "anthropic.claude-3-sonnet-20240229-v1:0"

1
type ClaudeBodyMsgSource struct {
2
        Type      string  `json:"type"`
3
        MediaType *string `json:"media_type,omitempty"`
4
        Data      *string `json:"data,omitempty"`
5
}
6
type ClaudeBodyMsgContent struct {
7
        Type   string               `json:"type"`
8
        Source *ClaudeBodyMsgSource `json:"source,omitempty"`
9
        Text   *string              `json:"text,omitempty"`
10
}
11
type ClaudeBodyMsg struct {
12
        Role    string                 `json:"role"`
13
        Content []ClaudeBodyMsgContent `json:"content"`
14
}
15
type ClaudeBody struct {
16
        AnthropicVersion string          `json:"anthropic_version"`
17
        MaxTokens        int             `json:"max_tokens"`
18
        System           string          `json:"system"`
19
        Messages         []ClaudeBodyMsg `json:"messages"`
20
}

1
// Prepare the request to bedrock
2
const mediaTypeImage = "image/jpeg"
3
prompt := "Please let the user know how their first image is similar to the other 3 and which one is the most similar?"
4
payload := ClaudeBody{
5
        AnthropicVersion: "bedrock-2023-05-31",
6
        MaxTokens:        1000,
7
        System:           "Please act as face comparison analyzer.",
8
        Messages: []ClaudeBodyMsg{
9
                        {
10
                            Role: "user",
11
                            Content: []ClaudeBodyMsgContent{
12
                                    {
13
                                            Type: "image",
14
                                            Source: &ClaudeBodyMsgSource{
15
                                                    Type:      "base64",
16
                                                    MediaType: aws.String(mediaTypeImage),
17
                                                    Data:      &imgB64,
18
                                            },
19
                                    },
20
                                    {
21
                                            Type: "image",
22
                                            Source: &ClaudeBodyMsgSource{
23
                                                    Type:      "base64",
24
                                                    MediaType: aws.String(mediaTypeImage),
25
                                                    Data:      &similarImgB64[0],
26
                                            },
27
                                    },
28
                                    {
29
                                            Type: "image",
30
                                            Source: &ClaudeBodyMsgSource{
31
                                                    Type:      "base64",
32
                                                    MediaType: aws.String(mediaTypeImage),
33
                                                    Data:      &similarImgB64[1],
34
                                            },
35
                                    },
36
                                    {
37
                                            Type: "image",
38
                                            Source: &ClaudeBodyMsgSource{
39
                                                    Type:      "base64",
40
                                                    MediaType: aws.String(mediaTypeImage),
41
                                                    Data:      &similarImgB64[2],
42
                                            },
43
                                    },
44
                                    {
45
                                            Type: "text",
46
                                            Text: &prompt,
47
                                    },
48
                            },
49
                    },
50
                },
51
}

1
bedrockBody, err := json.Marshal(payload)
2
if err != nil {
3
        return nil, fmt.Errorf("failed to get embedding from bedrock: %w", err)
4
}
5
bedrockReq := bedrockruntime.InvokeModelInput{
6
        ModelId:     aws.String(claude3SonnetV1ModelId),
7
        Body:        bedrockBody,
8
        ContentType: aws.String(contentTypeJson),
9
        Accept:      aws.String(contentTypeJson),
10
}

1
// Invoke the model with the request
2
bedrockResp, err := app.bedrock.InvokeModel(ctx, &bedrockReq)
3
if err != nil {
4
        return nil, fmt.Errorf("failed to get embedding from bedrock: %w", err)
5
}

1
description := gjson.GetBytes(bedrockResp.Body, "content.0.text").String()
2
3
return &description, nil

1
description, err := app.getImageSimilaritiesDescription(r.Context(), *stdImage, images)
2
if err != nil {
3
        log.Println("ERR: failed to describe similarities with images", err)
4
        http.Error(w, "Error describing similarities with images", http.StatusInternalServerError)
5
        return
6
}

1
type CelebMatchResponse struct {
2
        Description string   `json:"description"`
3
        Images      []string `json:"images"`
4
}

1
response := CelebMatchResponse{
2
        Description: *description,
3
        Images:      images,
4
}

1
jData, err := json.Marshal(response)
2
if err != nil {
3
        log.Fatalln("error serializing json", err)
4
}
5
// Set response headers and return JSON
6
w.Header().Set("Content-Type", contentTypeJson)
7
w.Header().Set("Content-Length", strconv.Itoa(len(jData)))
8
w.WriteHeader(http.StatusOK)
9
w.Write(jData)