DOC-5537 added local Go vector examples

Author: andy-stark-redis

content/develop/clients/go/vecsearch.md

@@ -66,19 +66,8 @@ go get github.com/henomis/lingoose/embedder/huggingface
 
 Add the following imports to your module's main program file:
 
-```go
-package main
-
-import (
-	"context"
-	"encoding/binary"
-	"fmt"
-	"math"
-
-	huggingfaceembedder "github.com/henomis/lingoose/embedder/huggingface"
-	"github.com/redis/go-redis/v9"
-)
-```
+{{< clients-example set="home_query_vec" step="import" lang_filter="Go" >}}
+{{< /clients-example >}}
 
 You must also create a [HuggingFace account](https://huggingface.co/join)
 and add a new access token to use the embedding model. See the
@@ -96,18 +85,8 @@ must convert this array to a `byte` string before adding it as a hash field.
 The function shown below uses Go's [`binary`](https://pkg.go.dev/encoding/binary)
 package to produce the `byte` string:
 
-```go
-func floatsToBytes(fs []float32) []byte {
-	buf := make([]byte, len(fs)*4)
-
-	for i, f := range fs {
-		u := math.Float32bits(f)
-		binary.NativeEndian.PutUint32(buf[i*4:], u)
-	}
-
-	return buf
-}
-```
+{{< clients-example set="home_query_vec" step="helper" lang_filter="Go" >}}
+{{< /clients-example >}}
 
 Note that if you are using [JSON]({{< relref "/develop/data-types/json" >}})
 objects to store your documents instead of hashes, then you should store
@@ -120,22 +99,8 @@ below).
 In the `main()` function, connect to Redis and delete any index previously
 created with the name `vector_idx`:
 
-```go
-ctx := context.Background()
-rdb := redis.NewClient(&redis.Options{
-    Addr:     "localhost:6379",
-    Password: "", // no password docs
-    DB:       0,  // use default DB
-    Protocol: 2,
-})
-
-rdb.FTDropIndexWithArgs(ctx,
-    "vector_idx",
-    &redis.FTDropIndexOptions{
-        DeleteDocs: true,
-    },
-)
-```
+{{< clients-example set="home_query_vec" step="connect" lang_filter="Go" >}}
+{{< /clients-example >}}
 
 Next, create the index.
 The schema in the example below specifies hash objects for storage and includes
@@ -149,38 +114,8 @@ indexing, the
 vector distance metric, `Float32` values to represent the vector's components,
 and 384 dimensions, as required by the `all-MiniLM-L6-v2` embedding model.
 
-```go
-_, err := rdb.FTCreate(ctx,
-    "vector_idx",
-    &redis.FTCreateOptions{
-        OnHash: true,
-        Prefix: []any{"doc:"},
-    },
-    &redis.FieldSchema{
-        FieldName: "content",
-        FieldType: redis.SearchFieldTypeText,
-    },
-    &redis.FieldSchema{
-        FieldName: "genre",
-        FieldType: redis.SearchFieldTypeTag,
-    },
-    &redis.FieldSchema{
-        FieldName: "embedding",
-        FieldType: redis.SearchFieldTypeVector,
-        VectorArgs: &redis.FTVectorArgs{
-            HNSWOptions: &redis.FTHNSWOptions{
-                Dim:            384,
-                DistanceMetric: "L2",
-                Type:           "FLOAT32",
-            },
-        },
-    },
-).Result()
-
-if err != nil {
-    panic(err)
-}
-```
+{{< clients-example set="home_query_vec" step="create_index" lang_filter="Go" >}}
+{{< /clients-example >}}
 
 ## Create an embedder instance
 
@@ -190,11 +125,8 @@ instance that uses the `sentence-transformers/all-MiniLM-L6-v2`
 model, passing your HuggingFace access token to the `WithToken()`
 method.
 
-```go
-hf := huggingfaceembedder.New().
-		WithToken("<your-access-token>").
-		WithModel("sentence-transformers/all-MiniLM-L6-v2")
-```
+{{< clients-example set="home_query_vec" step="embedder" lang_filter="Go" >}}
+{{< /clients-example >}}
 
 ## Add data
 
@@ -210,44 +142,8 @@ Use the `ToFloat32()` method of `Embedding` to produce the array of float
 values that we need, and use the `floatsToBytes()` function we defined
 above to convert this array to a `byte` string.
 
-```go
-sentences := []string{
-    "That is a very happy person",
-    "That is a happy dog",
-    "Today is a sunny day",
-}
-
-tags := []string{
-    "persons", "pets", "weather",
-}
-
-embeddings, err := hf.Embed(ctx, sentences)
-
-if err != nil {
-    panic(err)
-}
-
-for i, emb := range embeddings {
-    buffer := floatsToBytes(emb.ToFloat32())
-
-    if err != nil {
-        panic(err)
-    }
-
-    _, err = rdb.HSet(ctx,
-        fmt.Sprintf("doc:%v", i),
-        map[string]any{
-            "content":   sentences[i],
-            "genre":     tags[i],
-            "embedding": buffer,
-        },
-    ).Result()
-
-    if err != nil {
-        panic(err)
-    }
-}
-```
+{{< clients-example set="home_query_vec" step="add_data" lang_filter="Go" >}}
+{{< /clients-example >}}
 
 ## Run a query
 
@@ -263,47 +159,8 @@ the indexing, and passes it as a parameter when the query executes
 [Vector search]({{< relref "/develop/ai/search-and-query/query/vector-search" >}})
 for more information about using query parameters with embeddings).
 
-```go
-queryEmbedding, err := hf.Embed(ctx, []string{
-    "That is a happy person",
-})
-
-if err != nil {
-    panic(err)
-}
-
-buffer := floatsToBytes(queryEmbedding[0].ToFloat32())
-
-if err != nil {
-    panic(err)
-}
-
-results, err := rdb.FTSearchWithArgs(ctx,
-    "vector_idx",
-    "*=>[KNN 3 @embedding $vec AS vector_distance]",
-    &redis.FTSearchOptions{
-        Return: []redis.FTSearchReturn{
-            {FieldName: "vector_distance"},
-            {FieldName: "content"},
-        },
-        DialectVersion: 2,
-        Params: map[string]any{
-            "vec": buffer,
-        },
-    },
-).Result()
-
-if err != nil {
-    panic(err)
-}
-
-for _, doc := range results.Docs {
-    fmt.Printf(
-        "ID: %v, Distance:%v, Content:'%v'\n",
-        doc.ID, doc.Fields["vector_distance"], doc.Fields["content"],
-    )
-}
-```
+{{< clients-example set="home_query_vec" step="query" lang_filter="Go" >}}
+{{< /clients-example >}}
 
 The code is now ready to run, but note that it may take a while to complete when
 you run it for the first time (which happens because `huggingfacetransformer`
@@ -334,37 +191,8 @@ every query. Also, you must set `OnJSON` to `true` when you create the index.
 The code below shows these differences, but the index is otherwise very similar to
 the one created previously for hashes:
 
-```go
-_, err = rdb.FTCreate(ctx,
-    "vector_json_idx",
-    &redis.FTCreateOptions{
-        OnJSON: true,
-        Prefix: []any{"jdoc:"},
-    },
-    &redis.FieldSchema{
-        FieldName: "$.content",
-        As:        "content",
-        FieldType: redis.SearchFieldTypeText,
-    },
-    &redis.FieldSchema{
-        FieldName: "$.genre",
-        As:        "genre",
-        FieldType: redis.SearchFieldTypeTag,
-    },
-    &redis.FieldSchema{
-        FieldName: "$.embedding",
-        As:        "embedding",
-        FieldType: redis.SearchFieldTypeVector,
-        VectorArgs: &redis.FTVectorArgs{
-            HNSWOptions: &redis.FTHNSWOptions{
-                Dim:            384,
-                DistanceMetric: "L2",
-                Type:           "FLOAT32",
-            },
-        },
-    },
-).Result()
-```
+{{< clients-example set="home_query_vec" step="json_index" lang_filter="Go" >}}
+{{< /clients-example >}}
 
 Use [`JSONSet()`]({{< relref "/commands/json.set" >}}) to add the data
 instead of [`HSet()`]({{< relref "/commands/hset" >}}). The maps
@@ -375,23 +203,8 @@ specified using lists instead of binary strings. The loop below is similar
 to the one used previously to add the hash data, but it doesn't use the
 `floatsToBytes()` function to encode the `float32` array.
 
-```go
-for i, emb := range embeddings {
-    _, err = rdb.JSONSet(ctx,
-        fmt.Sprintf("jdoc:%v", i),
-        "$",
-        map[string]any{
-            "content":   sentences[i],
-            "genre":     tags[i],
-            "embedding": emb.ToFloat32(),
-        },
-    ).Result()
-
-    if err != nil {
-        panic(err)
-    }
-}
-```
+{{< clients-example set="home_query_vec" step="json_data" lang_filter="Go" >}}
+{{< /clients-example >}}
 
 The query is almost identical to the one for the hash documents. This
 demonstrates how the right choice of aliases for the JSON paths can
@@ -400,32 +213,8 @@ is that the vector parameter for the query is still specified as a
 binary string (using the `floatsToBytes()` method), even though the data for
 the `embedding` field of the JSON was specified as an array.
 
-```go
-jsonQueryEmbedding, err := hf.Embed(ctx, []string{
-    "That is a happy person",
-})
-
-if err != nil {
-    panic(err)
-}
-
-jsonBuffer := floatsToBytes(jsonQueryEmbedding[0].ToFloat32())
-
-jsonResults, err := rdb.FTSearchWithArgs(ctx,
-    "vector_json_idx",
-    "*=>[KNN 3 @embedding $vec AS vector_distance]",
-    &redis.FTSearchOptions{
-        Return: []redis.FTSearchReturn{
-            {FieldName: "vector_distance"},
-            {FieldName: "content"},
-        },
-        DialectVersion: 2,
-        Params: map[string]any{
-            "vec": jsonBuffer,
-        },
-    },
-).Result()
-```
+{{< clients-example set="home_query_vec" step="json_query" lang_filter="Go" >}}
+{{< /clients-example >}}
 
 Apart from the `jdoc:` prefixes for the keys, the result from the JSON
 query is the same as for hash: