From d736ffb13bd5fc5c587f9479522011436b729f10 Mon Sep 17 00:00:00 2001
From: Hayden <hayden.hhoang@gmail.com>
Date: Fri, 11 Oct 2024 22:30:33 +0700
Subject: [PATCH 1/3] Squashed commit of the following:

commit 2eebd4f822c83a817eedd5283d2e052a414aff1c
Author: Hayden <hayden.hhoang@gmail.com>
Date:   Fri Oct 11 22:16:43 2024 +0700

    docs(go): client installation

commit ba1ff8fc0dc29802cc61cfe46604228142439dc7
Author: Hayden <hayden.hhoang@gmail.com>
Date:   Thu Oct 10 22:13:26 2024 +0700

    docs(go): cluster operations

commit 1aa2be9b9eb4de9af7d0713e6ae1b81a1a4287b0
Author: Hayden <hayden.hhoang@gmail.com>
Date:   Thu Oct 10 21:32:11 2024 +0700

    docs(go): synonyms API

commit e9bf043d776e0e0b73db4ba5aa6b99f140524af0
Author: Hayden <hayden.hhoang@gmail.com>
Date:   Thu Oct 10 20:22:56 2024 +0700

    docs(go): collection alias API

commit 82b54a7fd159b9e5b92e18b67a742a513f83f2b6
Author: Hayden <hayden.hhoang@gmail.com>
Date:   Thu Oct 10 20:07:31 2024 +0700

    docs(go): api keys

commit 0fcadccd75f4383f87a8c4f7f7bcc474a9f09042
Author: Hayden <hayden.hhoang@gmail.com>
Date:   Wed Oct 9 23:13:33 2024 +0700

    docs(go): vector search

commit d5f0257dc2b4b977c44d38ac0dfef7b2d982aeb2
Author: Hayden <hayden.hhoang@gmail.com>
Date:   Mon Oct 7 21:56:05 2024 +0700

    docs(go): multi search API

commit 3dcf4aa62860904176bd4f1c507e2c09026bec26
Author: Hayden <hayden.hhoang@gmail.com>
Date:   Mon Oct 7 21:43:40 2024 +0700

    docs(go): code snippet for search & geosearch API

commit 6ddfc16f01b0a9cf8a400c920e4405eb9a050cea
Author: Hayden <hayden.hhoang@gmail.com>
Date:   Mon Oct 7 21:42:36 2024 +0700

    docs(go): code snippets for collection v27.1 API

commit 9236dfd5510a87526ab219632dee6a60efc14af0
Author: Hayden <hayden.hhoang@gmail.com>
Date:   Mon Oct 7 20:24:41 2024 +0700

    docs(go): code snippet for installing a client

commit 384945b083df7bc84faa48452de2609ab8c7435f
Author: Hayden <hayden.hhoang@gmail.com>
Date:   Thu Sep 19 21:31:34 2024 +0700

    docs(go): collections API

commit 61ceaebf7181579a261afefac82c8decc3506cbd
Author: Hayden <hayden.hhoang@gmail.com>
Date:   Thu Sep 19 19:49:22 2024 +0700

    docs(go): snippets for `/guide`

commit 4d4262694746e154fd62a80a22fab5f60868bb8f
Author: Hayden <hayden.hhoang@gmail.com>
Date:   Wed Sep 18 22:29:35 2024 +0700

    docs(golang): building-a-search-application snippets
---
 docs-site/content/27.0/api/collections.md     | 184 ++++--
 docs-site/content/27.1/api/api-keys.md        | 101 +++-
 .../content/27.1/api/cluster-operations.md    |  50 +-
 .../content/27.1/api/collection-alias.md      |  43 +-
 docs-site/content/27.1/api/collections.md     | 183 ++++--
 .../27.1/api/federated-multi-search.md        |  28 +-
 docs-site/content/27.1/api/geosearch.md       |  48 +-
 docs-site/content/27.1/api/search.md          | 124 +++-
 docs-site/content/27.1/api/synonyms.md        |  58 +-
 docs-site/content/27.1/api/vector-search.md   | 542 +++++++++++++++---
 .../guide/building-a-search-application.md    | 119 +++-
 docs-site/content/guide/high-availability.md  |  78 ++-
 .../content/guide/installing-a-client.md      |  17 +-
 .../search-delivery-network.md                |  38 +-
 14 files changed, 1285 insertions(+), 328 deletions(-)

diff --git a/docs-site/content/27.0/api/collections.md b/docs-site/content/27.0/api/collections.md
index bebf7fca..be35332b 100644
--- a/docs-site/content/27.0/api/collections.md
+++ b/docs-site/content/27.0/api/collections.md
@@ -6,7 +6,7 @@ sitemap:
 
 # Collections
 
-In Typesense, every record you index is called a `Document` and a group of documents with similar fields is called a `Collection`. 
+In Typesense, every record you index is called a `Document` and a group of documents with similar fields is called a `Collection`.
 A Collection is roughly equivalent to a table in a relational database.
 
 ## Create a collection
@@ -31,7 +31,7 @@ There are two ways to specify a schema:
 2. [Have Typesense automatically detect your fields and data types](#with-auto-schema-detection) based on the documents you index.
 
 The simplest option is [#2](#with-auto-schema-detection) where you don't have to worry about defining an explicit schema.
-But if you need more fine-grained control and/or validation, you want to use [#1](#with-pre-defined-schema) or even mix both together. 
+But if you need more fine-grained control and/or validation, you want to use [#1](#with-pre-defined-schema) or even mix both together.
 
 ### With pre-defined schema
 
@@ -39,9 +39,9 @@ Let's first create a collection with an explicit, pre-defined schema.
 
 This option gives you fine-grained control over your document fields' [data types](#field-types) and configures your collection to reject documents that don't match the data types defined in your schema ([by default](./documents.md#dealing-with-dirty-data)).
 
-If you want Typesense to automatically detect your schema for you, skip over to [auto-schema detection](#with-auto-schema-detection). 
+If you want Typesense to automatically detect your schema for you, skip over to [auto-schema detection](#with-auto-schema-detection).
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -168,7 +168,34 @@ final schema = Schema(
 
 await client.collections.create(schema);
 ```
-    
+
+  </template>
+  <template v-slot:Go>
+
+```go
+schema := &api.CollectionSchema{
+  Name: "companies",
+  Fields: []api.Field{
+    {
+      Name: "company_name",
+      Type: "string",
+    },
+    {
+      Name: "num_employees",
+      Type: "int32",
+    },
+    {
+      Name:  "country",
+      Type:  "string",
+      Facet: pointer.True(),
+    },
+  },
+  DefaultSortingField: pointer.String("num_employees"),
+}
+
+client.Collections().Create(context.Background(), schema)
+```
+
   </template>
   <template v-slot:Java>
 
@@ -251,22 +278,22 @@ See [Schema Parameters](#schema-parameters) for all available options, and [Fiel
 `POST ${TYPESENSE_HOST}/collections`
 
 :::warning IMPORTANT NOTE & TIP
-All fields you mention in a collection's schema will be indexed _in memory_. 
+All fields you mention in a collection's schema will be indexed _in memory_.
 
 There might be cases where you don't intend to search / filter / facet / group by a particular field and just want it to be stored (on disk) and returned as is when a document is a search hit.
-For eg: you can store image URLs in every document that you might use when displaying search results, but you might not want to text-search the actual URLs. 
+For eg: you can store image URLs in every document that you might use when displaying search results, but you might not want to text-search the actual URLs.
 
-You want to NOT mention these fields in the collection's schema or mark these fields as `index: false` (see `fields` [schema parameter](#schema-parameters) below) to mark it as an unindexed field. 
+You want to NOT mention these fields in the collection's schema or mark these fields as `index: false` (see `fields` [schema parameter](#schema-parameters) below) to mark it as an unindexed field.
 You can have any number of these additional unindexed fields in the documents when adding them to a collection - they will just be stored on disk, and will not take up any memory.
 :::
 
 ### With auto schema detection
- 
+
 If your field names are dynamic and not known upfront, or if you just want to keep things simple and index all fields you send in your documents by default,
-auto-schema detection should help you. 
+auto-schema detection should help you.
 
-You can define a wildcard field with the name `.*` and  type `auto` to let Typesense automatically 
-detect the type of the fields when you [add documents](./documents.md#index-a-single-document) to the collection. 
+You can define a wildcard field with the name `.*` and  type `auto` to let Typesense automatically
+detect the type of the fields when you [add documents](./documents.md#index-a-single-document) to the collection.
 In fact, you can use **any RegEx expression to define a field name**.
 
 <Tabs :tabs="['JSON']">
@@ -274,7 +301,7 @@ In fact, you can use **any RegEx expression to define a field name**.
 
 ```json
 {
-  "name": "companies",  
+  "name": "companies",
   "fields": [
     {"name": ".*", "type": "auto" }
   ]
@@ -334,9 +361,9 @@ You can control this default coercion behavior at write-time with the [`dirty_va
 
 #### Faceting fields with auto-schema detection
 
-[Faceting](./search.md#facet-results) is not enabled for a wildcard field `{"name": ".*" , ...}`, since that can consume a lot of memory, 
-especially for large text fields. However, you can still explicitly define specific fields (with or without RegEx names) to facet by 
-setting `facet: true` for them. 
+[Faceting](./search.md#facet-results) is not enabled for a wildcard field `{"name": ".*" , ...}`, since that can consume a lot of memory,
+especially for large text fields. However, you can still explicitly define specific fields (with or without RegEx names) to facet by
+setting `facet: true` for them.
 
 For e.g, when you define a schema like this:
 
@@ -357,7 +384,7 @@ This will only set field names that end with `_facet` in the document, as a face
 
 #### `Geopoint` and auto-schema detection
 
-A [`geopoint` field](#field-types) requires an explicit type definition, as the geo field value is represented as a 2-element 
+A [`geopoint` field](#field-types) requires an explicit type definition, as the geo field value is represented as a 2-element
 float field and we cannot differentiate between a lat/long definition and an actual float array.
 
 #### Indexing all but some fields
@@ -373,7 +400,7 @@ For eg, if you want to index all fields, except for fields that start with `desc
 
 ```json
 {
-  "name": "companies",  
+  "name": "companies",
   "fields": [
     {"name": ".*", "type": "auto" },
     {"name": ".*_facet", "type": "auto", "facet": true },
@@ -393,7 +420,7 @@ If an explicit definition is available for a field (`country` in the example abo
 preference to that before falling back to the wildcard definition.
 
 When such an explicit field definition is not available, the first document that contains a field with a given name
-determines the type of that field. 
+determines the type of that field.
 
 For example, if you index a document with a field named `title` and it is a
 string, then the next document that contains the field named `title` will be expected to have a string too.
@@ -406,8 +433,8 @@ string, then the next document that contains the field named `title` will be exp
 | name                  | yes      | Name of the collection you wish to create.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
 | fields                | yes      | A list of fields that you wish to index for [querying](./search.md#query-parameters), [filtering](./search.md#filter-results), [faceting](./search.md#facet-results), [grouping](./search.md#group-results) and [sorting](./search.md#sort-results). For each field, you have to specify at least it's `name` and [`type`](#field-types).<br><br> Eg: ```{"name": "title", "type": "string", "facet": false, "index": true}``` <br><br>`name` can be a simple string like `"name": "score"`. Or you can also use a RegEx to specify field names matching a pattern. For eg: if you want to specify that all fields starting with `score_` should be an integer, you can set name as `"name": "score_.*"`.<br><br>**Declaring a field as optional**<br>A field can be declared as optional by setting `"optional": true`.<br><br>**Declaring a field as a facet**<br>A field can be declared as a facetable field by setting `"facet": true`. Faceted fields are indexed verbatim without any tokenization or preprocessing. For example, if you are building a product search, `color` and `brand` could be defined as facet fields. Once a field is enabled for faceting in the schema, it can be used in the [`facet_by` search parameter](./search.md#facet-results)..<br><br>**Enabling stemming**<br>Stemming allows you to handle common word variations (singular / plurals, tense changes) of the same root word. For eg: searching for `walking`, will also return results with `walk`, `walked`, `walks`, etc when stemming is enabled. <br><br> Enable stemming on the contents of the field during indexing and querying by setting `"stem": true`. The actual value stored on disk is not affected. <br><br>We use the [Snowball stemmer](https://snowballstem.org/). Language selection for stemmer is automatically made from the value of the `locale` property associated with the field.<br><br>**Declaring a field as un-indexed**<br>You can set a field as un-indexed (you can't search/sort/filter/facet on it) by setting `"index": false`. This is useful when used along with [auto schema detection](#with-auto-schema-detection) and you need to [exclude certain fields from indexing](#indexing-all-but-some-fields).<br><br>**Prevent field from being stored on disk**:<br> Set `"store": false` to ensure that a field value is removed from the document before the document is saved to disk. <br><br>**Configuring language-specific tokenization:**<br> The default tokenizer that Typesense uses works for most languages, especially ones that separate words by spaces. However, based on feedback from users, we've added locale specific customizations for the following languages. You can enable these customizations for a field, by setting a field called `locale` inside the field definition. Eg: `{name: 'title', type: 'string', locale: 'ja'}` will enable the Japanese locale customizations for the field named `title`. <br><br>Here's the list of all language-specific customizations: <ul><li>`ja` - Japanese</li><li>`zh` - Chinese</li><li>`ko` - Korean</li><li>`th` - Thai</li><li>`el` - Greek</li><li>`ru` - Russian</li><li>`sr` - Serbian / Cyrillic</li><li>`uk` - Ukrainian</li><li>`be` - Belarusian</li> <li> For all other languages, you don't have to set the `locale` field.</li></ul> |
 | token_separators      | no       | List of symbols or special characters to be used for splitting the text into individual words _**in addition**_ to space and new-line characters.<br><br> For e.g. you can add `-` (hyphen) to this list to make a word like `non-stick` to be split on hyphen and indexed as two separate words. <br><br> Read [this guide article](../../guide/tips-for-searching-common-types-of-data.md) for more examples on how to use this setting.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| symbols_to_index      | no       | List of symbols or special characters to be indexed. <br><br>For e.g. you can add `+` to this list to make the word `c++` indexable verbatim. <br><br>Read [this guide article](../../guide/tips-for-searching-common-types-of-data.md) for more examples on how to use this setting.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 
-| default_sorting_field | no       | The name of an `int32 / float` field that determines the order in which the search results are ranked when a `sort_by` clause is not provided during searching. <br><br>This field must indicate some kind of popularity. For example, in a product search application, you could define `num_reviews` field as the `default_sorting_field` to rank products that have the most reviews higher by default.<br><br>Additionally, when a word in a search query matches multiple possible words (either during a prefix (partial word) search or because of a typo), this parameter is used to rank such equally matching records. <br><br>For e.g. Searching for "ap", will match records with "apple", "apply", "apart", "apron", or any of hundreds of similar words that start with "ap" in your dataset. Also, searching for "jofn", will match records with "john", "joan" and all similar variations that are 1-typo away in your dataset. <br><br>For performance reasons though, Typesense will only consider the top `4` prefixes or typo variations by default (the `4` is configurable using the [`max_candidates`](./search.md#ranking-and-sorting-parameters) search parameter, which defaults to `4`). <br><br>If `default_sorting_field` is NOT specified in the collection schema, then "top" is defined as the prefixes or typo variations with the most number of matching records. <br><br>But let's say you have a field called `popularity` in each record, and you want Typesense to use the value in that field to define the "top" records, you'd set that field as `default_sorting_field: popularity`. Typesense will then use the value of that field to fetch the top `max_candidates` number of terms that are most popular, and as users type in more characters, it will refine the search further to always rank the most popular prefixes highest.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | 
+| symbols_to_index      | no       | List of symbols or special characters to be indexed. <br><br>For e.g. you can add `+` to this list to make the word `c++` indexable verbatim. <br><br>Read [this guide article](../../guide/tips-for-searching-common-types-of-data.md) for more examples on how to use this setting.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| default_sorting_field | no       | The name of an `int32 / float` field that determines the order in which the search results are ranked when a `sort_by` clause is not provided during searching. <br><br>This field must indicate some kind of popularity. For example, in a product search application, you could define `num_reviews` field as the `default_sorting_field` to rank products that have the most reviews higher by default.<br><br>Additionally, when a word in a search query matches multiple possible words (either during a prefix (partial word) search or because of a typo), this parameter is used to rank such equally matching records. <br><br>For e.g. Searching for "ap", will match records with "apple", "apply", "apart", "apron", or any of hundreds of similar words that start with "ap" in your dataset. Also, searching for "jofn", will match records with "john", "joan" and all similar variations that are 1-typo away in your dataset. <br><br>For performance reasons though, Typesense will only consider the top `4` prefixes or typo variations by default (the `4` is configurable using the [`max_candidates`](./search.md#ranking-and-sorting-parameters) search parameter, which defaults to `4`). <br><br>If `default_sorting_field` is NOT specified in the collection schema, then "top" is defined as the prefixes or typo variations with the most number of matching records. <br><br>But let's say you have a field called `popularity` in each record, and you want Typesense to use the value in that field to define the "top" records, you'd set that field as `default_sorting_field: popularity`. Typesense will then use the value of that field to fetch the top `max_candidates` number of terms that are most popular, and as users type in more characters, it will refine the search further to always rank the most popular prefixes highest.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 
 ### Field parameters
 
@@ -454,7 +481,7 @@ Typesense allows you to index the following types of fields:
 
 ### Cloning a collection schema
 
-Here's how you can clone an existing collection's schema (documents are not copied), overrides and synonyms. 
+Here's how you can clone an existing collection's schema (documents are not copied), overrides and synonyms.
 
 ```shell
 curl -k "http://localhost:8108/collections?src_name=existing_coll" -X POST -H "Content-Type: application/json" \
@@ -463,17 +490,17 @@ curl -k "http://localhost:8108/collections?src_name=existing_coll" -X POST -H "C
       }'
 ```
 
-The above API call will create a new collection called `new_coll` that contains the schema, overrides and synonyms of 
-the collection `existing_coll`. The actual documents in the `existing_coll` collection are **not** copied, 
+The above API call will create a new collection called `new_coll` that contains the schema, overrides and synonyms of
+the collection `existing_coll`. The actual documents in the `existing_coll` collection are **not** copied,
 so this is primarily useful for creating new collections from an existing reference template.
 
 :::tip
-Cloning a collection this way, does **not** copy the data. 
+Cloning a collection this way, does **not** copy the data.
 :::
 
 ### Adding metadata to schema
 
-If you wish, you could populate a `metadata` object to the schema while creating a collection to add 
+If you wish, you could populate a `metadata` object to the schema while creating a collection to add
 details about the collection, for e.g. when it was created, who created it etc.
 
 ```json
@@ -513,7 +540,7 @@ You must first enable nested fields at a collection level via the `enable_nested
 ```shell{4,6-7}
 curl -k "http://localhost:8108/collections" -X POST -H "Content-Type: application/json" \
       -H "X-TYPESENSE-API-KEY: ${TYPESENSE_API_KEY}" -d '{
-        "name": "docs", 
+        "name": "docs",
         "enable_nested_fields": true,
         "fields": [
           {"name": "person", "type": "object"},
@@ -543,7 +570,7 @@ And say you only want to index the `zip` field inside the `address` nested objec
 ```shell{7}
 curl -k "http://localhost:8108/collections" -X POST -H "Content-Type: application/json" \
       -H "X-TYPESENSE-API-KEY: ${TYPESENSE_API_KEY}" -d '{
-        "name": "docs", 
+        "name": "docs",
         "enable_nested_fields": true,
         "fields": [
           {"name": "name", "type": "string"},
@@ -579,7 +606,7 @@ And say you only want to index the `zip` field inside each address object in the
 ```shell{7}
 curl -k "http://localhost:8108/collections" -X POST -H "Content-Type: application/json" \
       -H "X-TYPESENSE-API-KEY: ${TYPESENSE_API_KEY}" -d '{
-        "name": "docs", 
+        "name": "docs",
         "enable_nested_fields": true,
         "fields": [
           {"name": "name", "type": "string"},
@@ -608,7 +635,7 @@ For example, a document like this containing nested objects:
       "fieldB": ["valueB", "valueC", "valueD"]
     }
   }
-}  
+}
 ```
 
 would need to be flattened as:
@@ -631,9 +658,9 @@ At display time when parsing the results, you can then use the nested version.
 #### Indexing Dates
 
 Dates need to be converted into [Unix timestamps](https://en.wikipedia.org/wiki/Unix_time) and stored as `int64` fields in Typesense.
-Most languages have libraries that help do this conversion for you. 
+Most languages have libraries that help do this conversion for you.
 
-You'll then be able to use numerical operators like `<`, `>`, etc to filter records that are before or after or between dates. 
+You'll then be able to use numerical operators like `<`, `>`, etc to filter records that are before or after or between dates.
 
 #### Indexing other types of data
 
@@ -642,7 +669,7 @@ Read our dedicated guide article on how to index other common types of data like
 ## Retrieve a collection
 Retrieve the details of a collection, given its name.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -676,13 +703,20 @@ client.collections['companies'].retrieve
 
 ```dart
 await client.collection('companies').retrieve();
-```    
+```
 
   </template>
   <template v-slot:Java>
 
 ```java
 CollectionResponse collection = client.collections("companies").retrieve();
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Collection("companies").Retrieve(context.Background())
 ```
 
   </template>
@@ -732,13 +766,13 @@ curl -H "X-TYPESENSE-API-KEY: ${TYPESENSE_API_KEY}" \
 Returns a summary of all your collections. The collections are returned sorted by creation date, with the most recent collections appearing first.
 
 :::tip
-By default, ALL collections are returned, but you can use the `offset` and `limit` parameters to paginate on the 
+By default, ALL collections are returned, but you can use the `offset` and `limit` parameters to paginate on the
 collection listing.
 
 You can also set `exclude_fields=fields` to exclude the field definitions from being returned in the response.
 :::
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -779,6 +813,13 @@ await client.collections.retrieve();
 
 ```java
 CollectionResponse[] collectionResponses = client.collections().retrieve();
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Collections().Retrieve(context.Background())
 ```
 
   </template>
@@ -839,7 +880,7 @@ curl -H "X-TYPESENSE-API-KEY: ${TYPESENSE_API_KEY}" \
 ## Drop a collection
 Permanently drops a collection. This action cannot be undone. For large collections, this might have an impact on read latencies.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -880,6 +921,13 @@ await client.collection('companies').delete();
 
 ```java
 CollectionResponse collectionResponse = client.collections("companies").delete();
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Collection("companies").Delete(context.Background())
 ```
 
   </template>
@@ -890,7 +938,7 @@ let (collectionResponse, response) = try await client.collection(name: "companie
 ```
 
   </template>
-  
+
   <template v-slot:Shell>
 
 ```bash
@@ -943,7 +991,7 @@ Typesense supports updating all fields **except** the `id` field (since it's a s
 Let's see how we can add a new `company_category` field to the `companies` collection and also drop the existing
 `num_employees` field.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -970,7 +1018,7 @@ $update_schema = [
     [
       'name'  => 'company_category',
       'type'  => 'string'
-    ]    
+    ]
   ]
 ];
 $client->collections['companies']->update($update_schema);
@@ -981,7 +1029,7 @@ $client->collections['companies']->update($update_schema);
 
 ```py
 update_schema = {
-  'fields': [    
+  'fields': [
     {
       'name'  :  'num_employees',
       'drop'  :  True
@@ -1008,8 +1056,8 @@ update_schema = {
     {
       'name'  => 'company_category',
       'type'  => 'string'
-    }    
-  ]  
+    }
+  ]
 }
 client.collections['companies'].update(update_schema)
 ```
@@ -1021,7 +1069,7 @@ client.collections['companies'].update(update_schema)
 final updateSchema = UpdateSchema(
   {
     Field('num_employees', drop: true),
-    Field('company_category', Type.string)    
+    Field('company_category', Type.string)
   }
 );
 await client.collection('companies').update(updateSchema);
@@ -1037,6 +1085,20 @@ updateSchema.addFieldsItem(new Field().name("num_employees").drop(true))
 client.collections("companies").update(updateSchema);
 ```
 
+</template>
+<template v-slot:Go>
+
+```go
+updateSchema := &api.CollectionUpdateSchema{
+  Fields: []api.Field{
+    {Name: "num_employees", Drop: pointer.True()},
+    {Name: "company_category", Type: "string"},
+  },
+}
+
+client.Collection("companies").Update(context.Background(), updateSchema)
+```
+
 </template>
 <template v-slot:Swift>
 
@@ -1044,7 +1106,7 @@ client.collections("companies").update(updateSchema);
 let updateSchema = CollectionUpdateSchema(
   fields: [
     Field(name: "num_employees", drop: true),
-    Field(name: "company_category", type: "string")    
+    Field(name: "company_category", type: "string")
   ]
 )
 try await client.collections.update(updateSchema: updateSchema)
@@ -1062,7 +1124,7 @@ curl "http://localhost:8108/collections/companies" \
        -d '{
          "fields": [
            {"name": "num_employees", "drop": true },
-           {"name": "company_category", "type": "string" }           
+           {"name": "company_category", "type": "string" }
          ]
        }'
 ```
@@ -1112,7 +1174,7 @@ to the field you want to remove.
 `PATCH ${TYPESENSE_HOST}/collections/:collection`
 
 :::warning
-The schema update operation is a synchronous **blocking** operation. 
+The schema update operation is a synchronous **blocking** operation.
 
 When a schema update is in progress, all incoming writes to _that particular collection_ will wait for the schema update operation to finish.
 In a multi-node HA cluster, the schema update is executed on all nodes in the cluster in parallel. So writes will be blocked across the entire cluster while the schema update is in progress.
@@ -1130,22 +1192,22 @@ Since the alter operation can take a long time, this ensures that a client with
 not end up retrying the same alter request.
 :::
 
-The update operation consists of an initial validation step where the records on-disk are assessed to ensure 
-that they are compatible with the proposed schema change. For example, let's say there is a `string` field `A` which 
-is already present in the documents on-disk but is not part of the schema. If you try to update the collection 
-schema by adding a field `A` with type `integer`, the validation step will reject this change as it's incompatible 
+The update operation consists of an initial validation step where the records on-disk are assessed to ensure
+that they are compatible with the proposed schema change. For example, let's say there is a `string` field `A` which
+is already present in the documents on-disk but is not part of the schema. If you try to update the collection
+schema by adding a field `A` with type `integer`, the validation step will reject this change as it's incompatible
 with the type of data already present.
 
-If the validation is successful, the actual schema change is done and the records are 
-indexed / re-indexed / dropped as per the requested change. The process is complete as soon as the API call 
-returns (make sure you use a large client timeout value). Because of the blocking nature of the update, we 
-recommend doing the change during off-peak hours. 
+If the validation is successful, the actual schema change is done and the records are
+indexed / re-indexed / dropped as per the requested change. The process is complete as soon as the API call
+returns (make sure you use a large client timeout value). Because of the blocking nature of the update, we
+recommend doing the change during off-peak hours.
 
 Alternatively, you can also use the [alias feature](#using-an-alias) to do zero downtime schema changes.
 
 ### Modifying an existing field
 
-Since Typesense currently only supports adding/deleting a field, any modifications to an existing field should be 
+Since Typesense currently only supports adding/deleting a field, any modifications to an existing field should be
 expressed as a drop + add operation. All fields **except** the `id` field can be modified.
 
 For example, to add a `facet` property to the `company_category` field, we will drop + add it in the same change set:
@@ -1158,14 +1220,14 @@ curl "http://localhost:8108/collections/companies" \
        -d '{
          "fields": [
            {"name": "company_category", "drop": true },
-           {"name": "company_category", "type": "string", "facet": true }   
+           {"name": "company_category", "type": "string", "facet": true }
          ]
        }'
 ```
 
 ### Using an alias
 
-If you need to do zero-downtime schema changes, you could also re-create the collection fully with the updated schema and use 
+If you need to do zero-downtime schema changes, you could also re-create the collection fully with the updated schema and use
 the [Collection Alias](./collection-alias.md) feature to do a zero-downtime switch over to the new collection:
 
 Let's say you have a collection called `movies_jan_1` that you want to change the schema for.
@@ -1177,11 +1239,11 @@ Let's say you have a collection called `movies_jan_1` that you want to change th
 5. [Update the collection alias](./collection-alias.md#create-or-update-an-alias) to now point to the new collection. Eg: Update `movies` to now point to `movies_feb_1`.
 6. Stop your application from sending writes to the old collection and [drop the old collection](#drop-a-collection), `movies_jan_1` in our example.
 
-Once you update the alias, any search / indexing operations will go to the new collection (eg: `movies_feb_1`) 
+Once you update the alias, any search / indexing operations will go to the new collection (eg: `movies_feb_1`)
 without you having to do any additional application-side changes.
 
 ### Dynamic field additions
 
-If you only need to _add_ new fields to the schema on the fly, we recommend using [auto-schema detection](#with-auto-schema-detection) 
-when creating the collection. You can essentially define RegEx field names and when documents containing 
+If you only need to _add_ new fields to the schema on the fly, we recommend using [auto-schema detection](#with-auto-schema-detection)
+when creating the collection. You can essentially define RegEx field names and when documents containing
 new field names that match the RegEx come in, the new fields will automatically be added to the schema.
diff --git a/docs-site/content/27.1/api/api-keys.md b/docs-site/content/27.1/api/api-keys.md
index 86a58236..c71a919c 100644
--- a/docs-site/content/27.1/api/api-keys.md
+++ b/docs-site/content/27.1/api/api-keys.md
@@ -7,7 +7,7 @@ sitemap:
 # API Keys
 Typesense allows you to create API Keys with fine-grained access control. You can restrict access on a per-collection, per-action, per-record or even per-field level or a mixture of these.
 
-Read more about how to manage access to data in Typesense in this [dedicated guide article](../../guide/data-access-control.md). 
+Read more about how to manage access to data in Typesense in this [dedicated guide article](../../guide/data-access-control.md).
 
 :::warning
 We will be using the initial bootstrap key that you started Typesense with (via `--api-key`>) to create additional keys. It's **strongly recommended** that you don't use the bootstrap API key directly in your production applications. Instead you want to generate an appropriately-scoped key for the application at hand.
@@ -19,7 +19,7 @@ We will be using the initial bootstrap key that you started Typesense with (via
 
 Let's begin by creating an API key that allows you to do all operations, i.e. it's effectively an admin key and is equivalent to the key that you start Typesense with (via `--api-key`).
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -90,6 +90,17 @@ collectionValues.add("*");
 
 apiKeySchema.description("Admin Key").actions(actionValues).collections(collectionValues);
 ApiKey apiKey = client.keys().create(apiKeySchema);
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+key, err := client.Keys().Create(context.Background(), &api.ApiKeySchema{
+  Description: "Admin key.",
+  Actions:     []string{"*"},
+  Collections: []string{"*"},
+})
 ```
 
   </template>
@@ -128,7 +139,7 @@ The generated key is only returned during creation. You want to store this key c
 
 Let's now see how we can create a search-only key that allows you to limit the key's scope to only the search action, and also for only a specific collection.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -198,6 +209,17 @@ collectionValues.add("intbooks");
 apiKeySchema.description("Search only Key").actions(actionValues).collections(collectionValues);
 
 ApiKey apiKey = client.keys().create(apiKeySchema);
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Keys().Create(context.Background(), &api.ApiKeySchema{
+  Description: "Search-only companies key.",
+  Actions:     []string{"documents:search"},
+  Collections: []string{"companies"},
+})
 ```
 
   </template>
@@ -283,7 +305,7 @@ The collection names can contain regular expressions. For example, if you have m
 
 This is a _sample_ list of actions.
 
-In general, you want to use the format `resource:verb` pattern to indicate an action, where `verb` can be one of `create`, `delete`, `get`, `list`, `search`, or `*`. 
+In general, you want to use the format `resource:verb` pattern to indicate an action, where `verb` can be one of `create`, `delete`, `get`, `list`, `search`, or `*`.
 
 #### Collection actions
 
@@ -371,7 +393,7 @@ In general, you want to use the format `resource:verb` pattern to indicate an ac
 ## Retrieve an API Key
 Retrieve (metadata about) a key.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -412,6 +434,13 @@ final key = await client.key(1).retrieve();
 
 ```java
 ApiKey apiKey = client.keys(1).retrieve();
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+key, err := client.Key(1).Retrieve(context.Background())
 ```
 
   </template>
@@ -460,7 +489,7 @@ Notice how only the key prefix is returned when you retrieve a key. Due to secur
 ## List all Keys
 Retrieve (metadata about) all keys.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -500,6 +529,13 @@ await client.keys.retrieve();
 
 ```java
 ApiKeysResponse apiKeysResponse = client.keys().retrieve();
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Keys().Retrieve(context.Background())
 ```
 
   </template>
@@ -568,7 +604,7 @@ Notice how only the key prefix is returned when you retrieve a key. Due to secur
 ## Delete API Key
 Delete an API key given its ID.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -609,6 +645,13 @@ final key = await client.key(1).delete();
 
 ```java
 ApiKey apiKey = client.keys(1).delete();
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Key(1).Delete(context.Background())
 ```
 
   </template>
@@ -651,20 +694,20 @@ curl 'http://localhost:8108/keys/1' \
 You can generate scoped search API keys that have embedded search parameters in them. This is useful in a few different scenarios:
 
 1. You can index data from multiple users/customers in a single Typesense collection (aka multi-tenancy) and create scoped search keys with embedded `filter_by` parameters that only allow users access to their own subset of data.
-2. You can embed any [search parameters](search.md#search-parameters) (for eg: `exclude_fields` or `limit_hits`) to prevent users from being able to modify it client-side. 
+2. You can embed any [search parameters](search.md#search-parameters) (for eg: `exclude_fields` or `limit_hits`) to prevent users from being able to modify it client-side.
 
 When you use these scoped search keys in a search API call, the parameters you embedded in them will be automatically applied by Typesense and users will not be able to override them.
 
 ### Example
 
-Let's take the first use-case of storing data from multiple users in a single collection. 
+Let's take the first use-case of storing data from multiple users in a single collection.
 
-1. First you'd add an array field called `accessible_to_user_ids` to each document in your collection, listing all the users who should have access to the document in that field. 
+1. First you'd add an array field called `accessible_to_user_ids` to each document in your collection, listing all the users who should have access to the document in that field.
 2. Then when a user with say `user_id: 1` lands on your search experience, you'd generate a unique scoped search API key for them (on your backend server), with an embedded filter of `filter_by: accessible_to_user_ids:=1`.
 
 When you make a search API call with this scoped search API key, Typesense will automatically apply the `filter_by`, so the user will effectively only have access to search through documents that have their own user_id listed in the `accessible_to_user_ids` field.
 
-Now let's say you also don't want users to know the entire list of users_ids that have access to a document, you can also embed `exclude_fields: accessible_to_user_ids` in the scoped API key, so it doesn't get returned in the response.  
+Now let's say you also don't want users to know the entire list of users_ids that have access to a document, you can also embed `exclude_fields: accessible_to_user_ids` in the scoped API key, so it doesn't get returned in the response.
 
 ### Role-based access <Badge text="Advanced"/>
 
@@ -687,10 +730,10 @@ Once a parent Search API Key is revoked, all scoped API keys that were generated
 
 ### Usage
 
-We can generate scoped search API keys without having to make any calls to the Typesense server. 
+We can generate scoped search API keys without having to make any calls to the Typesense server.
 
-We should use an API key that we previously generated with a **search scope (only)**, create an HMAC digest of the 
-parameters with this key and use that as the API key. Our client libraries handle this logic for you, but you can also 
+We should use an API key that we previously generated with a **search scope (only)**, create an HMAC digest of the
+parameters with this key and use that as the API key. Our client libraries handle this logic for you, but you can also
 generate scoped search API keys from the command line.
 
 ::: tip
@@ -698,11 +741,11 @@ Scoped search API keys must only be created from a parent API key that has no ot
 :::
 
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Shell']">
   <template v-slot:JavaScript>
 
 ```js
-// Make sure that the parent search key you use to generate a scoped search key 
+// Make sure that the parent search key you use to generate a scoped search key
 //  has no other permissions besides `documents:search`
 
 keyWithSearchPermissions = 'RN23GFr1s6jQ9kgSNg2O7fYcAUXU7127'
@@ -714,7 +757,7 @@ client.keys().generateScopedSearchKey(keyWithSearchPermissions, {'filter_by': 'c
   <template v-slot:PHP>
 
 ```php
-// Make sure that the parent search key you use to generate a scoped search key 
+// Make sure that the parent search key you use to generate a scoped search key
 //  has no other permissions besides `documents:search`
 
 $keyWithSearchPermissions = 'RN23GFr1s6jQ9kgSNg2O7fYcAUXU7127';
@@ -725,7 +768,7 @@ $client->keys->generateScopedSearchKey($keyWithSearchPermissions, ['filter_by' =
   <template v-slot:Python>
 
 ```py
-# Make sure that the parent search key you use to generate a scoped search key 
+# Make sure that the parent search key you use to generate a scoped search key
 #  has no other permissions besides `documents:search`
 
 key_with_search_permissions = 'RN23GFr1s6jQ9kgSNg2O7fYcAUXU7127'
@@ -736,7 +779,7 @@ client.keys.generate_scoped_search_key(key_with_search_permissions, {"filter_by"
   <template v-slot:Ruby>
 
 ```rb
-# Make sure that the parent search key you use to generate a scoped search key 
+# Make sure that the parent search key you use to generate a scoped search key
 #  has no other permissions besides `documents:search`
 
 key_with_search_permissions = 'RN23GFr1s6jQ9kgSNg2O7fYcAUXU7127'
@@ -747,7 +790,7 @@ client.keys().generate_scoped_search_key(key_with_search_permissions, {'filter_b
   <template v-slot:Dart>
 
 ```dart
-// Make sure that the parent search key you use to generate a scoped search key 
+// Make sure that the parent search key you use to generate a scoped search key
 //  has no other permissions besides `documents:search`
 
 final keyWithSearchPermissions = 'RN23GFr1s6jQ9kgSNg2O7fYcAUXU7127';
@@ -758,7 +801,7 @@ client.keys.generateScopedSearchKey(keyWithSearchPermissions, {'filter_by': 'com
   <template v-slot:Java>
 
 ```java
-// Make sure that the parent search key you use to generate a scoped search key 
+// Make sure that the parent search key you use to generate a scoped search key
 //  has no other permissions besides `documents:search`
 String keyWithSearchPermissions = "RN23GFr1s6jQ9kgSNg2O7fYcAUXU7127";
 
@@ -766,13 +809,27 @@ HashMap<String, Object> parameters = new HashMap<>();
 parameters.put("filter_by", "company_id:124");
 
 String scopedSearchKey = client.keys().generateScopedSearchKey(keyWithSearchPermissions,parameters);
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+// Make sure that the parent search key you use to generate a scoped search key
+//  has no other permissions besides `documents:search`
+
+keyWithSearchPermissions := "RN23GFr1s6jQ9kgSNg2O7fYcAUXU7127"
+client.Keys().GenerateScopedSearchKey(keyWithSearchPermissions, map[string]interface{}{
+  "filter_by":  "company_id:124",
+  "expires_at": 1906054106,
+})
 ```
 
   </template>
   <template v-slot:Shell>
 
 ```bash
-# Make sure that the parent search key you use to generate a scoped search key 
+# Make sure that the parent search key you use to generate a scoped search key
 #  has no other permissions besides `documents:search`
 
 KEY_WITH_SEARCH_PERMISSIONS="RN23GFr1s6jQ9kgSNg2O7fYcAUXU7127"
diff --git a/docs-site/content/27.1/api/cluster-operations.md b/docs-site/content/27.1/api/cluster-operations.md
index 51991f7c..6dbd5ab3 100644
--- a/docs-site/content/27.1/api/cluster-operations.md
+++ b/docs-site/content/27.1/api/cluster-operations.md
@@ -11,7 +11,7 @@ Creates a point-in-time snapshot of a Typesense node's state and data in the spe
 
 You can then backup the snapshot directory that gets created and later restore it as a data directory, as needed.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -55,6 +55,13 @@ HashMap<String, String> query = new HashMap<>();
 query.put("snapshot_path","/tmp/typesense-data-snapshot");
 
 client.operations.perform("snapshot",query);
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Operations().Snapshot(context.Background(), "/tmp/typesense-data-snapshot")
 ```
 
   </template>
@@ -100,8 +107,8 @@ curl "http://localhost:8108/operations/snapshot?snapshot_path=/tmp/typesense-dat
 
 ## Compacting the on-disk database
 
-Typesense uses RocksDB to store your documents on the disk. If you do frequent writes or updates, you could benefit 
-from running a compaction of the underlying RocksDB database. This could reduce the size of the database and decrease 
+Typesense uses RocksDB to store your documents on the disk. If you do frequent writes or updates, you could benefit
+from running a compaction of the underlying RocksDB database. This could reduce the size of the database and decrease
 read latency.
 
 While the database will _not_ block during this operation, we recommend running it during off-peak hours.
@@ -118,7 +125,7 @@ Triggers a follower node to initiate the raft voting process, which triggers lea
 
 The follower node that you run this operation against will become the new leader, once this command succeeds.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -159,6 +166,13 @@ await client.operations.initLeaderElection();
 
 ```java
 client.operations.perform("vote");
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Operations().Vote(context.Background())
 ```
 
   </template>
@@ -251,7 +265,7 @@ curl "http://localhost:8108/config" \
 
 ## Clear cache
 
-Responses of search requests that are sent with `use_cache` parameter are cached in a LRU cache. To clear 
+Responses of search requests that are sent with `use_cache` parameter are cached in a LRU cache. To clear
 this cache completely:
 
 ```shell
@@ -268,7 +282,7 @@ curl -H "X-TYPESENSE-API-KEY: ${TYPESENSE_API_KEY}" -X POST \
 
 Get current RAM, CPU, Disk & Network usage metrics.
 
-<Tabs :tabs="['Dart','Java','Swift','Shell']">
+<Tabs :tabs="['Dart','Java','Go','Swift','Shell']">
   <template v-slot:Dart>
 
 ```dart
@@ -279,6 +293,12 @@ await client.metrics.retrieve();
 
 ```java
 client.metrics.retrieve();
+```
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Metrics().Retrieve(context.Background())
 ```
   </template>
   <template v-slot:Swift>
@@ -347,11 +367,17 @@ Get stats about API endpoints.
 
 This endpoint returns average requests per second and latencies for all requests in the last 10 seconds.
 
-<Tabs :tabs="['Dart','Swift','Shell']">
+<Tabs :tabs="['Dart','Go','Swift','Shell']">
   <template v-slot:Dart>
 
 ```dart
 await client.stats.retrieve();
+```
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Stats().Retrieve(context.Background())
 ```
   </template>
   <template v-slot:Swift>
@@ -407,11 +433,17 @@ If you use Prometheus, here's a community-maintained project that lets you perio
 
 Get health information about a Typesense node.
 
-<Tabs :tabs="['Dart','Swift','Shell']">
+<Tabs :tabs="['Dart','Go','Swift','Shell']">
   <template v-slot:Dart>
 
 ```dart
 await client.health.retrieve();
+```
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Health(context.Background(), 3*time.Second)
 ```
   </template>
   <template v-slot:Swift>
@@ -442,7 +474,7 @@ curl "http://localhost:8108/health"
   </template>
 </Tabs>
 
-When a node is running out of memory / disk, the API response will have an additional `resource_error` field that's 
+When a node is running out of memory / disk, the API response will have an additional `resource_error` field that's
 set to either `OUT_OF_DISK` or `OUT_OF_MEMORY`.
 
 #### Definition
diff --git a/docs-site/content/27.1/api/collection-alias.md b/docs-site/content/27.1/api/collection-alias.md
index d292da3b..6f502f2f 100644
--- a/docs-site/content/27.1/api/collection-alias.md
+++ b/docs-site/content/27.1/api/collection-alias.md
@@ -21,7 +21,7 @@ Convenient isn't it? Let's now look at how we can create, update and manage alia
 
 ## Create or Update an alias
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -90,6 +90,18 @@ CollectionAliasSchema collectionAlias = new CollectionAliasSchema();
 collectionAlias.collectionName("companies_june11");
 
 client.aliases().upsert("companies", collectionAlias);
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+aliasedCollection := &api.CollectionAliasSchema{
+  CollectionName: "companies_june11",
+}
+
+// Creates/updates an alias called `companies` to the `companies_june11` collection
+client.Aliases().Upsert(context.Background(), "companies", aliasedCollection)
 ```
 
   </template>
@@ -136,13 +148,13 @@ curl "http://localhost:8108/aliases/companies" -X PUT \
 
 ### Arguments
 | Parameter      | Required    |Description                                            |
-| -------------- | ----------- |-------------------------------------------------------| 
+| -------------- | ----------- |-------------------------------------------------------|
 |collection_name	|yes	|Name of the collection you wish to map the alias to.|
 
 ## Retrieve an alias
 We can find out which collection an alias points to by fetching it.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -183,6 +195,13 @@ await client.alias('companies').retrieve();
 
 ```java
 CollectionAliasSchema collectionAlias = client.aliases("companies").retrieve();
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Alias("companies").Retrieve(context.Background())
 ```
 
   </template>
@@ -225,7 +244,7 @@ curl -H "X-TYPESENSE-API-KEY: ${TYPESENSE_API_KEY}" \
 ## List all aliases
 List all aliases and the corresponding collections that they map to.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -266,6 +285,13 @@ await client.aliases.retrieve();
 
 ```java
 CollectionAliasesResponse collectionAliasesResponse = client.aliases().retrieve();
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Aliases().Retrieve(context.Background())
 ```
 
   </template>
@@ -314,7 +340,7 @@ curl -H "X-TYPESENSE-API-KEY: ${TYPESENSE_API_KEY}" \
 
 ## Delete an alias
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -355,6 +381,13 @@ await client.alias('companies').delete();
 
 ```java
 CollectionAliasSchema collectionAlias = client.aliases("companies").delete();
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Alias("companies").Delete(context.Background())
 ```
 
   </template>
diff --git a/docs-site/content/27.1/api/collections.md b/docs-site/content/27.1/api/collections.md
index 20a4dbcc..9d41b7e4 100644
--- a/docs-site/content/27.1/api/collections.md
+++ b/docs-site/content/27.1/api/collections.md
@@ -6,7 +6,7 @@ sitemap:
 
 # Collections
 
-In Typesense, every record you index is called a `Document` and a group of documents with similar fields is called a `Collection`. 
+In Typesense, every record you index is called a `Document` and a group of documents with similar fields is called a `Collection`.
 A Collection is roughly equivalent to a table in a relational database.
 
 ## Create a collection
@@ -31,7 +31,7 @@ There are two ways to specify a schema:
 2. [Have Typesense automatically detect your fields and data types](#with-auto-schema-detection) based on the documents you index.
 
 The simplest option is [#2](#with-auto-schema-detection) where you don't have to worry about defining an explicit schema.
-But if you need more fine-grained control and/or validation, you want to use [#1](#with-pre-defined-schema) or even mix both together. 
+But if you need more fine-grained control and/or validation, you want to use [#1](#with-pre-defined-schema) or even mix both together.
 
 ### With pre-defined schema
 
@@ -39,9 +39,9 @@ Let's first create a collection with an explicit, pre-defined schema.
 
 This option gives you fine-grained control over your document fields' [data types](#field-types) and configures your collection to reject documents that don't match the data types defined in your schema ([by default](./documents.md#dealing-with-dirty-data)).
 
-If you want Typesense to automatically detect your schema for you, skip over to [auto-schema detection](#with-auto-schema-detection). 
+If you want Typesense to automatically detect your schema for you, skip over to [auto-schema detection](#with-auto-schema-detection).
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -168,7 +168,33 @@ final schema = Schema(
 
 await client.collections.create(schema);
 ```
-    
+
+  </template>
+  <template v-slot:Go>
+
+```go
+schema := &api.CollectionSchema{
+  Name: "companies",
+  Fields: []api.Field{
+    {
+      Name: "company_name",
+      Type: "string",
+    },
+    {
+      Name: "num_employees",
+      Type: "int32",
+    },
+    {
+      Name:  "country",
+      Type:  "string",
+      Facet: pointer.True(),
+    },
+  },
+  DefaultSortingField: pointer.String("num_employees"),
+}
+
+client.Collections().Create(context.Background(), schema)
+```
   </template>
   <template v-slot:Java>
 
@@ -251,22 +277,22 @@ See [Schema Parameters](#schema-parameters) for all available options, and [Fiel
 `POST ${TYPESENSE_HOST}/collections`
 
 :::warning IMPORTANT NOTE & TIP
-All fields you mention in a collection's schema will be indexed _in memory_. 
+All fields you mention in a collection's schema will be indexed _in memory_.
 
 There might be cases where you don't intend to search / filter / facet / group by a particular field and just want it to be stored (on disk) and returned as is when a document is a search hit.
-For eg: you can store image URLs in every document that you might use when displaying search results, but you might not want to text-search the actual URLs. 
+For eg: you can store image URLs in every document that you might use when displaying search results, but you might not want to text-search the actual URLs.
 
-You want to NOT mention these fields in the collection's schema or mark these fields as `index: false` (see `fields` [schema parameter](#schema-parameters) below) to mark it as an unindexed field. 
+You want to NOT mention these fields in the collection's schema or mark these fields as `index: false` (see `fields` [schema parameter](#schema-parameters) below) to mark it as an unindexed field.
 You can have any number of these additional unindexed fields in the documents when adding them to a collection - they will just be stored on disk, and will not take up any memory.
 :::
 
 ### With auto schema detection
- 
+
 If your field names are dynamic and not known upfront, or if you just want to keep things simple and index all fields you send in your documents by default,
-auto-schema detection should help you. 
+auto-schema detection should help you.
 
-You can define a wildcard field with the name `.*` and  type `auto` to let Typesense automatically 
-detect the type of the fields when you [add documents](./documents.md#index-a-single-document) to the collection. 
+You can define a wildcard field with the name `.*` and  type `auto` to let Typesense automatically
+detect the type of the fields when you [add documents](./documents.md#index-a-single-document) to the collection.
 In fact, you can use **any RegEx expression to define a field name**.
 
 <Tabs :tabs="['JSON']">
@@ -274,7 +300,7 @@ In fact, you can use **any RegEx expression to define a field name**.
 
 ```json
 {
-  "name": "companies",  
+  "name": "companies",
   "fields": [
     {"name": ".*", "type": "auto" }
   ]
@@ -334,9 +360,9 @@ You can control this default coercion behavior at write-time with the [`dirty_va
 
 #### Faceting fields with auto-schema detection
 
-[Faceting](./search.md#facet-results) is not enabled for a wildcard field `{"name": ".*" , ...}`, since that can consume a lot of memory, 
-especially for large text fields. However, you can still explicitly define specific fields (with or without RegEx names) to facet by 
-setting `facet: true` for them. 
+[Faceting](./search.md#facet-results) is not enabled for a wildcard field `{"name": ".*" , ...}`, since that can consume a lot of memory,
+especially for large text fields. However, you can still explicitly define specific fields (with or without RegEx names) to facet by
+setting `facet: true` for them.
 
 For e.g, when you define a schema like this:
 
@@ -357,7 +383,7 @@ This will only set field names that end with `_facet` in the document, as a face
 
 #### `Geopoint` and auto-schema detection
 
-A [`geopoint` field](#field-types) requires an explicit type definition, as the geo field value is represented as a 2-element 
+A [`geopoint` field](#field-types) requires an explicit type definition, as the geo field value is represented as a 2-element
 float field and we cannot differentiate between a lat/long definition and an actual float array.
 
 #### Indexing all but some fields
@@ -373,7 +399,7 @@ For eg, if you want to index all fields, except for fields that start with `desc
 
 ```json
 {
-  "name": "companies",  
+  "name": "companies",
   "fields": [
     {"name": ".*", "type": "auto" },
     {"name": ".*_facet", "type": "auto", "facet": true },
@@ -393,7 +419,7 @@ If an explicit definition is available for a field (`country` in the example abo
 preference to that before falling back to the wildcard definition.
 
 When such an explicit field definition is not available, the first document that contains a field with a given name
-determines the type of that field. 
+determines the type of that field.
 
 For example, if you index a document with a field named `title` and it is a
 string, then the next document that contains the field named `title` will be expected to have a string too.
@@ -406,8 +432,8 @@ string, then the next document that contains the field named `title` will be exp
 | name                  | yes      | Name of the collection you wish to create.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
 | fields                | yes      | A list of fields that you wish to index for [querying](./search.md#query-parameters), [filtering](./search.md#filter-results), [faceting](./search.md#facet-results), [grouping](./search.md#group-results) and [sorting](./search.md#sort-results). For each field, you have to specify at least it's `name` and [`type`](#field-types).<br><br> Eg: ```{"name": "title", "type": "string", "facet": false, "index": true}``` <br><br>`name` can be a simple string like `"name": "score"`. Or you can also use a RegEx to specify field names matching a pattern. For eg: if you want to specify that all fields starting with `score_` should be an integer, you can set name as `"name": "score_.*"`.<br><br>**Declaring a field as optional**<br>A field can be declared as optional by setting `"optional": true`.<br><br>**Declaring a field as a facet**<br>A field can be declared as a facetable field by setting `"facet": true`. Faceted fields are indexed verbatim without any tokenization or preprocessing. For example, if you are building a product search, `color` and `brand` could be defined as facet fields. Once a field is enabled for faceting in the schema, it can be used in the [`facet_by` search parameter](./search.md#facet-results)..<br><br>**Enabling stemming**<br>Stemming allows you to handle common word variations (singular / plurals, tense changes) of the same root word. For eg: searching for `walking`, will also return results with `walk`, `walked`, `walks`, etc when stemming is enabled. <br><br> Enable stemming on the contents of the field during indexing and querying by setting `"stem": true`. The actual value stored on disk is not affected. <br><br>We use the [Snowball stemmer](https://snowballstem.org/). Language selection for stemmer is automatically made from the value of the `locale` property associated with the field.<br><br>**Declaring a field as un-indexed**<br>You can set a field as un-indexed (you can't search/sort/filter/facet on it) by setting `"index": false`. This is useful when used along with [auto schema detection](#with-auto-schema-detection) and you need to [exclude certain fields from indexing](#indexing-all-but-some-fields).<br><br>**Prevent field from being stored on disk**:<br> Set `"store": false` to ensure that a field value is removed from the document before the document is saved to disk. <br><br>**Configuring language-specific tokenization:**<br> The default tokenizer that Typesense uses works for most languages, especially ones that separate words by spaces. However, based on feedback from users, we've added locale specific customizations for the following languages. You can enable these customizations for a field, by setting a field called `locale` inside the field definition. Eg: `{name: 'title', type: 'string', locale: 'ja'}` will enable the Japanese locale customizations for the field named `title`. <br><br>Here's the list of all language-specific customizations: <ul><li>`ja` - Japanese</li><li>`zh` - Chinese</li><li>`ko` - Korean</li><li>`th` - Thai</li><li>`el` - Greek</li><li>`ru` - Russian</li><li>`sr` - Serbian / Cyrillic</li><li>`uk` - Ukrainian</li><li>`be` - Belarusian</li> <li> For all other languages, you don't have to set the `locale` field.</li></ul> |
 | token_separators      | no       | List of symbols or special characters to be used for splitting the text into individual words _**in addition**_ to space and new-line characters.<br><br> For e.g. you can add `-` (hyphen) to this list to make a word like `non-stick` to be split on hyphen and indexed as two separate words. <br><br> Read [this guide article](../../guide/tips-for-searching-common-types-of-data.md) for more examples on how to use this setting.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| symbols_to_index      | no       | List of symbols or special characters to be indexed. <br><br>For e.g. you can add `+` to this list to make the word `c++` indexable verbatim. <br><br>Read [this guide article](../../guide/tips-for-searching-common-types-of-data.md) for more examples on how to use this setting.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 
-| default_sorting_field | no       | The name of an `int32 / float` field that determines the order in which the search results are ranked when a `sort_by` clause is not provided during searching. <br><br>This field must indicate some kind of popularity. For example, in a product search application, you could define `num_reviews` field as the `default_sorting_field` to rank products that have the most reviews higher by default.<br><br>Additionally, when a word in a search query matches multiple possible words (either during a prefix (partial word) search or because of a typo), this parameter is used to rank such equally matching records. <br><br>For e.g. Searching for "ap", will match records with "apple", "apply", "apart", "apron", or any of hundreds of similar words that start with "ap" in your dataset. Also, searching for "jofn", will match records with "john", "joan" and all similar variations that are 1-typo away in your dataset. <br><br>For performance reasons though, Typesense will only consider the top `4` prefixes or typo variations by default (the `4` is configurable using the [`max_candidates`](./search.md#ranking-and-sorting-parameters) search parameter, which defaults to `4`). <br><br>If `default_sorting_field` is NOT specified in the collection schema, then "top" is defined as the prefixes or typo variations with the most number of matching records. <br><br>But let's say you have a field called `popularity` in each record, and you want Typesense to use the value in that field to define the "top" records, you'd set that field as `default_sorting_field: popularity`. Typesense will then use the value of that field to fetch the top `max_candidates` number of terms that are most popular, and as users type in more characters, it will refine the search further to always rank the most popular prefixes highest.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | 
+| symbols_to_index      | no       | List of symbols or special characters to be indexed. <br><br>For e.g. you can add `+` to this list to make the word `c++` indexable verbatim. <br><br>Read [this guide article](../../guide/tips-for-searching-common-types-of-data.md) for more examples on how to use this setting.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| default_sorting_field | no       | The name of an `int32 / float` field that determines the order in which the search results are ranked when a `sort_by` clause is not provided during searching. <br><br>This field must indicate some kind of popularity. For example, in a product search application, you could define `num_reviews` field as the `default_sorting_field` to rank products that have the most reviews higher by default.<br><br>Additionally, when a word in a search query matches multiple possible words (either during a prefix (partial word) search or because of a typo), this parameter is used to rank such equally matching records. <br><br>For e.g. Searching for "ap", will match records with "apple", "apply", "apart", "apron", or any of hundreds of similar words that start with "ap" in your dataset. Also, searching for "jofn", will match records with "john", "joan" and all similar variations that are 1-typo away in your dataset. <br><br>For performance reasons though, Typesense will only consider the top `4` prefixes or typo variations by default (the `4` is configurable using the [`max_candidates`](./search.md#ranking-and-sorting-parameters) search parameter, which defaults to `4`). <br><br>If `default_sorting_field` is NOT specified in the collection schema, then "top" is defined as the prefixes or typo variations with the most number of matching records. <br><br>But let's say you have a field called `popularity` in each record, and you want Typesense to use the value in that field to define the "top" records, you'd set that field as `default_sorting_field: popularity`. Typesense will then use the value of that field to fetch the top `max_candidates` number of terms that are most popular, and as users type in more characters, it will refine the search further to always rank the most popular prefixes highest.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
 
 ### Field parameters
 
@@ -454,7 +480,7 @@ Typesense allows you to index the following types of fields:
 
 ### Cloning a collection schema
 
-Here's how you can clone an existing collection's schema (documents are not copied), overrides and synonyms. 
+Here's how you can clone an existing collection's schema (documents are not copied), overrides and synonyms.
 
 ```shell
 curl -k "http://localhost:8108/collections?src_name=existing_coll" -X POST -H "Content-Type: application/json" \
@@ -463,17 +489,17 @@ curl -k "http://localhost:8108/collections?src_name=existing_coll" -X POST -H "C
       }'
 ```
 
-The above API call will create a new collection called `new_coll` that contains the schema, overrides and synonyms of 
-the collection `existing_coll`. The actual documents in the `existing_coll` collection are **not** copied, 
+The above API call will create a new collection called `new_coll` that contains the schema, overrides and synonyms of
+the collection `existing_coll`. The actual documents in the `existing_coll` collection are **not** copied,
 so this is primarily useful for creating new collections from an existing reference template.
 
 :::tip
-Cloning a collection this way, does **not** copy the data. 
+Cloning a collection this way, does **not** copy the data.
 :::
 
 ### Adding metadata to schema
 
-If you wish, you could populate a `metadata` object to the schema while creating a collection to add 
+If you wish, you could populate a `metadata` object to the schema while creating a collection to add
 details about the collection, for e.g. when it was created, who created it etc.
 
 ```json
@@ -513,7 +539,7 @@ You must first enable nested fields at a collection level via the `enable_nested
 ```shell{4,6-7}
 curl -k "http://localhost:8108/collections" -X POST -H "Content-Type: application/json" \
       -H "X-TYPESENSE-API-KEY: ${TYPESENSE_API_KEY}" -d '{
-        "name": "docs", 
+        "name": "docs",
         "enable_nested_fields": true,
         "fields": [
           {"name": "person", "type": "object"},
@@ -543,7 +569,7 @@ And say you only want to index the `zip` field inside the `address` nested objec
 ```shell{7}
 curl -k "http://localhost:8108/collections" -X POST -H "Content-Type: application/json" \
       -H "X-TYPESENSE-API-KEY: ${TYPESENSE_API_KEY}" -d '{
-        "name": "docs", 
+        "name": "docs",
         "enable_nested_fields": true,
         "fields": [
           {"name": "name", "type": "string"},
@@ -579,7 +605,7 @@ And say you only want to index the `zip` field inside each address object in the
 ```shell{7}
 curl -k "http://localhost:8108/collections" -X POST -H "Content-Type: application/json" \
       -H "X-TYPESENSE-API-KEY: ${TYPESENSE_API_KEY}" -d '{
-        "name": "docs", 
+        "name": "docs",
         "enable_nested_fields": true,
         "fields": [
           {"name": "name", "type": "string"},
@@ -608,7 +634,7 @@ For example, a document like this containing nested objects:
       "fieldB": ["valueB", "valueC", "valueD"]
     }
   }
-}  
+}
 ```
 
 would need to be flattened as:
@@ -631,9 +657,9 @@ At display time when parsing the results, you can then use the nested version.
 #### Indexing Dates
 
 Dates need to be converted into [Unix timestamps](https://en.wikipedia.org/wiki/Unix_time) and stored as `int64` fields in Typesense.
-Most languages have libraries that help do this conversion for you. 
+Most languages have libraries that help do this conversion for you.
 
-You'll then be able to use numerical operators like `<`, `>`, etc to filter records that are before or after or between dates. 
+You'll then be able to use numerical operators like `<`, `>`, etc to filter records that are before or after or between dates.
 
 #### Indexing other types of data
 
@@ -642,7 +668,7 @@ Read our dedicated guide article on how to index other common types of data like
 ## Retrieve a collection
 Retrieve the details of a collection, given its name.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -676,13 +702,20 @@ client.collections['companies'].retrieve
 
 ```dart
 await client.collection('companies').retrieve();
-```    
+```
 
   </template>
   <template v-slot:Java>
 
 ```java
 CollectionResponse collection = client.collections("companies").retrieve();
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Collection("companies").Retrieve(context.Background())
 ```
 
   </template>
@@ -732,13 +765,13 @@ curl -H "X-TYPESENSE-API-KEY: ${TYPESENSE_API_KEY}" \
 Returns a summary of all your collections. The collections are returned sorted by creation date, with the most recent collections appearing first.
 
 :::tip
-By default, ALL collections are returned, but you can use the `offset` and `limit` parameters to paginate on the 
+By default, ALL collections are returned, but you can use the `offset` and `limit` parameters to paginate on the
 collection listing.
 
 You can also set `exclude_fields=fields` to exclude the field definitions from being returned in the response.
 :::
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -779,6 +812,13 @@ await client.collections.retrieve();
 
 ```java
 CollectionResponse[] collectionResponses = client.collections().retrieve();
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Collections().Retrieve(context.Background())
 ```
 
   </template>
@@ -839,7 +879,7 @@ curl -H "X-TYPESENSE-API-KEY: ${TYPESENSE_API_KEY}" \
 ## Drop a collection
 Permanently drops a collection. This action cannot be undone. For large collections, this might have an impact on read latencies.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -880,6 +920,13 @@ await client.collection('companies').delete();
 
 ```java
 CollectionResponse collectionResponse = client.collections("companies").delete();
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Collection("companies").Delete(context.Background())
 ```
 
   </template>
@@ -890,7 +937,7 @@ let (collectionResponse, response) = try await client.collection(name: "companie
 ```
 
   </template>
-  
+
   <template v-slot:Shell>
 
 ```bash
@@ -943,7 +990,7 @@ Typesense supports updating all fields **except** the `id` field (since it's a s
 Let's see how we can add a new `company_category` field to the `companies` collection and also drop the existing
 `num_employees` field.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -970,7 +1017,7 @@ $update_schema = [
     [
       'name'  => 'company_category',
       'type'  => 'string'
-    ]    
+    ]
   ]
 ];
 $client->collections['companies']->update($update_schema);
@@ -981,7 +1028,7 @@ $client->collections['companies']->update($update_schema);
 
 ```py
 update_schema = {
-  'fields': [    
+  'fields': [
     {
       'name'  :  'num_employees',
       'drop'  :  True
@@ -1008,8 +1055,8 @@ update_schema = {
     {
       'name'  => 'company_category',
       'type'  => 'string'
-    }    
-  ]  
+    }
+  ]
 }
 client.collections['companies'].update(update_schema)
 ```
@@ -1021,7 +1068,7 @@ client.collections['companies'].update(update_schema)
 final updateSchema = UpdateSchema(
   {
     Field('num_employees', drop: true),
-    Field('company_category', Type.string)    
+    Field('company_category', Type.string)
   }
 );
 await client.collection('companies').update(updateSchema);
@@ -1037,6 +1084,20 @@ updateSchema.addFieldsItem(new Field().name("num_employees").drop(true))
 client.collections("companies").update(updateSchema);
 ```
 
+</template>
+<template v-slot:Go>
+
+```go
+updateSchema := &api.CollectionUpdateSchema{
+  Fields: []api.Field{
+    {Name: "num_employees", Drop: pointer.True()},
+    {Name: "company_category", Type: "string"},
+  },
+}
+
+client.Collection("companies").Update(context.Background(), updateSchema)
+```
+
 </template>
 <template v-slot:Swift>
 
@@ -1044,7 +1105,7 @@ client.collections("companies").update(updateSchema);
 let updateSchema = CollectionUpdateSchema(
   fields: [
     Field(name: "num_employees", drop: true),
-    Field(name: "company_category", type: "string")    
+    Field(name: "company_category", type: "string")
   ]
 )
 try await client.collections.update(updateSchema: updateSchema)
@@ -1062,7 +1123,7 @@ curl "http://localhost:8108/collections/companies" \
        -d '{
          "fields": [
            {"name": "num_employees", "drop": true },
-           {"name": "company_category", "type": "string" }           
+           {"name": "company_category", "type": "string" }
          ]
        }'
 ```
@@ -1112,7 +1173,7 @@ to the field you want to remove.
 `PATCH ${TYPESENSE_HOST}/collections/:collection`
 
 :::warning
-The schema update operation is a synchronous **blocking** operation. 
+The schema update operation is a synchronous **blocking** operation.
 
 When a schema update is in progress, all incoming writes to _that particular collection_ will wait for the schema update operation to finish.
 In a multi-node HA cluster, the schema update is executed on all nodes in the cluster in parallel. So writes will be blocked across the entire cluster while the schema update is in progress.
@@ -1130,22 +1191,22 @@ Since the alter operation can take a long time, this ensures that a client with
 not end up retrying the same alter request.
 :::
 
-The update operation consists of an initial validation step where the records on-disk are assessed to ensure 
-that they are compatible with the proposed schema change. For example, let's say there is a `string` field `A` which 
-is already present in the documents on-disk but is not part of the schema. If you try to update the collection 
-schema by adding a field `A` with type `integer`, the validation step will reject this change as it's incompatible 
+The update operation consists of an initial validation step where the records on-disk are assessed to ensure
+that they are compatible with the proposed schema change. For example, let's say there is a `string` field `A` which
+is already present in the documents on-disk but is not part of the schema. If you try to update the collection
+schema by adding a field `A` with type `integer`, the validation step will reject this change as it's incompatible
 with the type of data already present.
 
-If the validation is successful, the actual schema change is done and the records are 
-indexed / re-indexed / dropped as per the requested change. The process is complete as soon as the API call 
-returns (make sure you use a large client timeout value). Because of the blocking nature of the update, we 
-recommend doing the change during off-peak hours. 
+If the validation is successful, the actual schema change is done and the records are
+indexed / re-indexed / dropped as per the requested change. The process is complete as soon as the API call
+returns (make sure you use a large client timeout value). Because of the blocking nature of the update, we
+recommend doing the change during off-peak hours.
 
 Alternatively, you can also use the [alias feature](#using-an-alias) to do zero downtime schema changes.
 
 ### Modifying an existing field
 
-Since Typesense currently only supports adding/deleting a field, any modifications to an existing field should be 
+Since Typesense currently only supports adding/deleting a field, any modifications to an existing field should be
 expressed as a drop + add operation. All fields **except** the `id` field can be modified.
 
 For example, to add a `facet` property to the `company_category` field, we will drop + add it in the same change set:
@@ -1158,14 +1219,14 @@ curl "http://localhost:8108/collections/companies" \
        -d '{
          "fields": [
            {"name": "company_category", "drop": true },
-           {"name": "company_category", "type": "string", "facet": true }   
+           {"name": "company_category", "type": "string", "facet": true }
          ]
        }'
 ```
 
 ### Using an alias
 
-If you need to do zero-downtime schema changes, you could also re-create the collection fully with the updated schema and use 
+If you need to do zero-downtime schema changes, you could also re-create the collection fully with the updated schema and use
 the [Collection Alias](./collection-alias.md) feature to do a zero-downtime switch over to the new collection:
 
 Let's say you have a collection called `movies_jan_1` that you want to change the schema for.
@@ -1177,11 +1238,11 @@ Let's say you have a collection called `movies_jan_1` that you want to change th
 5. [Update the collection alias](./collection-alias.md#create-or-update-an-alias) to now point to the new collection. Eg: Update `movies` to now point to `movies_feb_1`.
 6. Stop your application from sending writes to the old collection and [drop the old collection](#drop-a-collection), `movies_jan_1` in our example.
 
-Once you update the alias, any search / indexing operations will go to the new collection (eg: `movies_feb_1`) 
+Once you update the alias, any search / indexing operations will go to the new collection (eg: `movies_feb_1`)
 without you having to do any additional application-side changes.
 
 ### Dynamic field additions
 
-If you only need to _add_ new fields to the schema on the fly, we recommend using [auto-schema detection](#with-auto-schema-detection) 
-when creating the collection. You can essentially define RegEx field names and when documents containing 
+If you only need to _add_ new fields to the schema on the fly, we recommend using [auto-schema detection](#with-auto-schema-detection)
+when creating the collection. You can essentially define RegEx field names and when documents containing
 new field names that match the RegEx come in, the new fields will automatically be added to the schema.
diff --git a/docs-site/content/27.1/api/federated-multi-search.md b/docs-site/content/27.1/api/federated-multi-search.md
index b86812a7..9f5eb205 100644
--- a/docs-site/content/27.1/api/federated-multi-search.md
+++ b/docs-site/content/27.1/api/federated-multi-search.md
@@ -10,7 +10,7 @@ You can send multiple search requests in a single HTTP request, using the Multi-
 You can also use this feature to do a **federated search** across multiple collections in a single HTTP request.
 For eg: in an ecommerce products dataset, you can show results from both a "products" collection, and a "brands" collection to the user, by searching them in parallel with a `multi_search` request.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -166,6 +166,32 @@ HashMap<String,String> commonSearchParams = new HashMap<>();
 commonSearchParams.put("query_by","name");
 
 client.multiSearch.perform(searchRequests, commonSearchParams);
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+searchRequests := api.MultiSearchSearchesParameter{
+  Searches: []api.MultiSearchCollectionParameters{
+    {
+      Collection: "products",
+      Q:          pointer.String("shoe"),
+      FilterBy:   pointer.String("price:=[50..120]"),
+    },
+    {
+      Collection: "brands",
+      Q:          pointer.String("Nike"),
+    },
+  },
+}
+
+// Search parameters that are common to all searches go here
+commonSearchParams := &api.MultiSearchParams{
+  QueryBy: pointer.String("name"),
+}
+
+client.MultiSearch.Perform(context.Background(), commonSearchParams, searchRequests)
 ```
 
   </template>
diff --git a/docs-site/content/27.1/api/geosearch.md b/docs-site/content/27.1/api/geosearch.md
index a90b6dee..a31d1ca9 100644
--- a/docs-site/content/27.1/api/geosearch.md
+++ b/docs-site/content/27.1/api/geosearch.md
@@ -10,7 +10,7 @@ Typesense supports geo search on fields containing latitude and longitude values
 
 Let's create a collection called `places` with a field called `location` of type `geopoint`.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -147,19 +147,45 @@ collectionschema.name("places")
                 .defaultSortingField("points");
 
 CollectionResponse collectionResponse = client.collections().create(collectionSchema);
+```
+
+  </template>
+<template v-slot:Go>
+
+```go
+schema := &api.CollectionSchema{
+  Name: "places",
+  Fields: []api.Field{
+    {
+      Name: "title",
+      Type: "string",
+    },
+    {
+      Name: "points",
+      Type: "int32",
+    },
+    {
+      Name: "location",
+      Type: "geopoint",
+    },
+  },
+  DefaultSortingField: pointer.String("points"),
+}
+
+client.Collections().Create(context.Background(), schema)
 ```
 
   </template>
   <template v-slot:Shell>
 
 ```bash
-curl -k "http://localhost:8108/collections" -X POST 
+curl -k "http://localhost:8108/collections" -X POST
       -H "Content-Type: application/json" \
       -H "X-TYPESENSE-API-KEY: ${TYPESENSE_API_KEY}" -d '{
         "name": "places",
         "fields": [
           {"name": "title", "type": "string" },
-          {"name": "points", "type": "int32" }, 
+          {"name": "points", "type": "int32" },
           {"name": "location", "type": "geopoint"}
         ],
         "default_sorting_field": "points"
@@ -280,7 +306,7 @@ We can now search for places within a given radius of a given latlong
 In addition, let's also sort the records that are closest to a given
 location (this location can be the same or different from the latlong used for filtering).
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -363,6 +389,20 @@ SearchParameters searchParameters = new SearchParameters()
                                         .filterBy("location:(48.90615915923891, 2.3435897727061175, 5.1 km)")
                                         .sortBy("location(48.853, 2.344):asc");
 SearchResult searchResult = client.collections("places").documents().search(searchParameters);
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+searchParameters := &api.SearchCollectionParams{
+  Q:        pointer.String("*"),
+  QueryBy:  pointer.String("title"),
+  FilterBy: pointer.String("location:(48.90615915923891, 2.3435897727061175, 5.1 km)"),
+  SortBy:   pointer.String("location(48.853, 2.344):asc"),
+}
+
+client.Collection("places").Documents().Search(context.Background(), searchParameters)
 ```
 
   </template>
diff --git a/docs-site/content/27.1/api/search.md b/docs-site/content/27.1/api/search.md
index 1c121352..2f091da3 100644
--- a/docs-site/content/27.1/api/search.md
+++ b/docs-site/content/27.1/api/search.md
@@ -9,7 +9,7 @@ sitemap:
 In Typesense, a search consists of a query against one or more text fields and a list of filters against numerical or facet fields.
 You can also sort and facet your results.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -90,6 +90,20 @@ SearchParameters searchParameters = new SearchParameters()
                                         .filterBy("num_employees:>100")
                                         .sortBy("num_employees:desc");
 SearchResult searchResult = client.collections("companies").documents().search(searchParameters);
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+searchParameters := &api.SearchCollectionParams{
+  Q:        pointer.String("stark"),
+  QueryBy:  pointer.String("company_name"),
+  FilterBy: pointer.String("num_employees:>100"),
+  SortBy:   pointer.String("num_employees:desc"),
+}
+
+client.Collection("companies").Documents().Search(context.Background(), searchParameters)
 ```
 
   </template>
@@ -329,8 +343,8 @@ Note that you need to enable faceting for fields in the [Collection Schema](./co
 {
   fields: [
     {
-      facet: true, 
-      name: "<field>", 
+      facet: true,
+      name: "<field>",
       type: "<datatype>"
     }
   ]
@@ -345,13 +359,13 @@ You can also sort facets on the value of a sibling field like this: `recipe.name
 
 ### Mapping facet strings
 
-Pass a comma separated string of nested facet fields into the `facet_return_parent` parameter, whose parent object should be returned in facet response. 
+Pass a comma separated string of nested facet fields into the `facet_return_parent` parameter, whose parent object should be returned in facet response.
 
 For e.g. when you set this to `facet_return_parent: color.name`, this will return the parent `color` object as parent property in the facet response.
 
 ### Facet ranges
 
-For numerical fields, you can provide a list of ranges and corresponding labels on which the documents should be 
+For numerical fields, you can provide a list of ranges and corresponding labels on which the documents should be
 faceted upon.
 
 For example, if your documents contain a `rating` field, and you want to facet the ratings as
@@ -363,12 +377,12 @@ For example, if your documents contain a `rating` field, and you want to facet t
 }
 ```
 
-This will bucket the `rating` values into the ranges requested and count the documents in each of the ranges to 
-produce the facet counts. 
+This will bucket the `rating` values into the ranges requested and count the documents in each of the ranges to
+produce the facet counts.
 
 NOTE: range start values are inclusive, but the range end values are exclusive in nature.
 
-You can leave start / end range value blank to cover the minimum / maximum value respectively. In the example below, 
+You can leave start / end range value blank to cover the minimum / maximum value respectively. In the example below,
 the max range value is omitted so that the `others` facet label will cover all values greater than or equal to 100.
 
 ```json
@@ -377,14 +391,14 @@ the max range value is omitted so that the `others` facet label will cover all v
 }
 ```
 
-Faceting by range requires the field to have `sort` property enabled. This is enabled by default for all numerical fields, 
+Faceting by range requires the field to have `sort` property enabled. This is enabled by default for all numerical fields,
 unless you've explicitly configured otherwise.
 
 🔗 You'll find detailed documentation for `facet_by` in the [Faceting Parameters](#faceting-parameters) table above.
 
 ## Sort Results
 
-You can use the `sort_by` search parameter to sort results by upto 3 fields in a tie-breaking mechanism - 
+You can use the `sort_by` search parameter to sort results by upto 3 fields in a tie-breaking mechanism -
 if the first field has the same values, then the second field is used. If the 1st and 2nd fields have the same values, then the 3rd field is used to break the tie.
 
 The text similarity score is exposed as a special `_text_match` field that you can use in the list of sorting fields.
@@ -393,7 +407,7 @@ The text similarity score is exposed as a special `_text_match` field that you c
 
 ### Sorting on numeric values
 
-Sorting is enabled by default on all numeric and boolean values. You can directly use these fields in the `sort_by` parameter. 
+Sorting is enabled by default on all numeric and boolean values. You can directly use these fields in the `sort_by` parameter.
 
 ### Sorting on strings
 
@@ -407,9 +421,9 @@ For e.g. here's a collection schema where sorting is allowed on the `email` stri
   "fields": [
     {"name": "name", "type": "string" },
     {
-      "name": "email", 
-      "type": "string", 
-      "sort": true 
+      "name": "email",
+      "type": "string",
+      "sort": true
     }
   ]
 }
@@ -451,7 +465,7 @@ This will prioritize candidates that have relevant work experience and are locat
 
 ### Sorting based on filter score
 
-Instead of sorting on just `true / false` values like above, we can also provide custom scores to the records matching a bunch of filter clauses. 
+Instead of sorting on just `true / false` values like above, we can also provide custom scores to the records matching a bunch of filter clauses.
 
 For example, if we have a `shoes` collection and if we wish to rank all `Nike` shoes ahead of `Adidas` shoes, we can do:
 
@@ -461,7 +475,7 @@ For example, if we have a `shoes` collection and if we wish to rank all `Nike` s
 }
 ```
 
-There can be as many expressions as needed in the `_eval` and each of those expressions can be as complex as 
+There can be as many expressions as needed in the `_eval` and each of those expressions can be as complex as
 standard `filter_by` expressions.
 
 ### Sorting null, empty or missing values
@@ -503,7 +517,7 @@ To group on a particular field, it must be a faceted field.
 
 Grouping returns the hits in a nested structure, that's different from the plain JSON response format we saw earlier. Let's repeat the query we made earlier with a `group_by` parameter:
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -596,6 +610,21 @@ SearchParameters searchParameters = new SearchParameters()
                                         .groupBy("country")
                                         .groupLimit(1);
 SearchResult searchResult = client.collections("companies").documents().search(searchParameters);
+```
+  </template>
+  <template v-slot:Go>
+
+```go
+searchParameters := &api.SearchCollectionParams{
+  Q:          pointer.String("stark"),
+  QueryBy:    pointer.String("company_name"),
+  FilterBy:   pointer.String("num_employees:>100"),
+  SortBy:     pointer.String("num_employees:desc"),
+  GroupBy:    pointer.String("country"),
+  GroupLimit: pointer.Int(1),
+}
+
+client.Collection("companies").Documents().Search(context.Background(), searchParameters)
 ```
   </template>
   <template v-slot:Swift>
@@ -686,7 +715,7 @@ You can also sort the results by the sizes of the groups by using `_group_found`
 
 ```json{2}
 {
-  "sort_by": "_group_found:desc" 
+  "sort_by": "_group_found:desc"
 }
 ```
 
@@ -709,18 +738,18 @@ Read more in the [Ranking and Relevance Guide](../../guide/ranking-and-relevance
 
 ## Presets
 
-Search presets allow you to store a bunch of search parameters together, and reference them by a name. You can then 
-use this preset name when you make a search request, instead of passing all the search parameters individually 
+Search presets allow you to store a bunch of search parameters together, and reference them by a name. You can then
+use this preset name when you make a search request, instead of passing all the search parameters individually
 in each search request.
 
 You can then change the preset configuration on the Typesense side, to change your search parameters, without having to re-deploy your application.
 
-For example, you can create a preset configuration called a `listing_view` which does a wildcard search and sorts 
+For example, you can create a preset configuration called a `listing_view` which does a wildcard search and sorts
 the results by a `popularity` score.
 
 Let's create a preset with name `listing_view`.
 
-<Tabs :tabs="['JavaScript','Dart','Shell']">
+<Tabs :tabs="['JavaScript','Dart','Go','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -744,6 +773,24 @@ Let's create a preset with name `listing_view`.
   });
 ```
 
+  </template>
+  <template v-slot:Go>
+
+```go
+preset := &api.PresetUpsertSchema{}
+preset.Value.FromMultiSearchSearchesParameter(api.MultiSearchSearchesParameter{
+  Searches: []api.MultiSearchCollectionParameters{
+    {
+      Collection: "products",
+      Q:          pointer.String("*"),
+      SortBy:     pointer.String("popularity"),
+    },
+  },
+})
+
+client.Presets().Upsert(context.Background(), "listing-view", preset)
+```
+
   </template>
   <template v-slot:Shell>
 
@@ -758,7 +805,7 @@ curl "http://localhost:8108/presets/listing_view" -X PUT \
 
 You can refer to this preset configuration during a search operation.
 
-<Tabs :tabs="['JavaScript','Dart','Shell']">
+<Tabs :tabs="['JavaScript','Dart','Go','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -774,6 +821,18 @@ await client.multiSearch().perform({},{
 await client.multiSearch.perform({}, queryParams: {
   'preset': 'listing_view'
 });
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.MultiSearch.Perform(context.Background(),
+  &api.MultiSearchParams{
+    Preset: pointer.String("listing_view"),
+  },
+  api.MultiSearchSearchesParameter{},
+)
 ```
 
   </template>
@@ -786,12 +845,12 @@ curl -H "X-TYPESENSE-API-KEY: ${TYPESENSE_API_KEY}"  -X POST \
   </template>
 </Tabs>
 
-You can use the preset configuration for a `GET .../search` end-point as well. 
+You can use the preset configuration for a `GET .../search` end-point as well.
 
-The only requirement is that for 
+The only requirement is that for
 `GET .../search`, the stored preset value should be a simple dictionary of search configurations, like this.
 
-<Tabs :tabs="['Dart','Shell']">
+<Tabs :tabs="['Dart','Go','Shell']">
   <template v-slot:Dart>
 
 ```dart
@@ -806,6 +865,19 @@ The only requirement is that for
   });
 ```
 
+  </template>
+  <template v-slot:Go>
+
+```go
+preset := &api.PresetUpsertSchema{}
+preset.Value.FromSearchParameters(api.SearchParameters{
+  Q:      "*",
+  SortBy: pointer.String("popularity"),
+})
+
+client.Presets().Upsert(context.Background(), "listing-view", preset)
+```
+
   </template>
   <template v-slot:Shell>
 
diff --git a/docs-site/content/27.1/api/synonyms.md b/docs-site/content/27.1/api/synonyms.md
index 6670af24..a155722f 100644
--- a/docs-site/content/27.1/api/synonyms.md
+++ b/docs-site/content/27.1/api/synonyms.md
@@ -21,7 +21,7 @@ When using Synonyms and [Overrides](./curation.md) together, Overrides are handl
 
 ### Multi-way synonym
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -91,6 +91,18 @@ synonym.addSynonymsItem("blazer").addSynonymsItem("coat").addSynonymsItem("jacke
 
 // Creates/updates a synonym called `coat-synonyms` in the `products` collection
 client.collections("products").synonyms().upsert("coat-synonyms", synonym);
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+synonym := &api.SearchSynonymSchema{
+  Synonyms: []string{"blazer", "coat", "jacket"},
+}
+
+// Creates/updates a synonym called `coat-synonyms` in the `products` collection
+client.Collection("products").Synonyms().Upsert(context.Background(), "coat-synonyms", synonym)
 ```
 
   </template>
@@ -134,7 +146,7 @@ curl "http://localhost:8108/collections/products/synonyms/coat-synonyms" -X PUT
 
 ### One-way synonym
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -210,6 +222,19 @@ synonym.root("smart phone");
 
 // Creates/updates a synonym called `smart-phone-synonyms` in the `products` collection
 client.collections("products").synonyms().upsert("smart-phone-synonyms", synonym);
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+synonym := &api.SearchSynonymSchema{
+  Root:     pointer.String("smart phone"),
+  Synonyms: []string{"iphone", "android"},
+}
+
+// Creates/updates a synonym called `smart-phone-synonyms` in the `products` collection
+client.Collection("products").Synonyms().Upsert(context.Background(), "smart-phone-synonyms", synonym)
 ```
 
   </template>
@@ -272,7 +297,7 @@ curl "http://localhost:8108/collections/products/synonyms/smart-phone-synonyms"
 ## Retrieve a synonym
 We can retrieve a single synonym.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -313,6 +338,13 @@ await client.collection('products').synonym('coat-synonyms').retrieve();
 
 ```java
 SearchSynonym searchSynonym = client.collections("products").synonyms("coat-synonyms").retrieve();
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Collection("products").Synonym("coat-synonyms").Retrieve(context.Background())
 ```
 
   </template>
@@ -354,10 +386,10 @@ curl -H "X-TYPESENSE-API-KEY: ${TYPESENSE_API_KEY}" "http://localhost:8108/colle
 ## List all synonyms
 List all synonyms associated with a given collection.
 
-NOTE: By default, ALL synonyms are returned, but you can use the `offset` and `limit` parameters to 
+NOTE: By default, ALL synonyms are returned, but you can use the `offset` and `limit` parameters to
 paginate on the listing.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -398,6 +430,13 @@ await client.collection('products').synonyms.retrieve();
 
 ```java
 SearchSynonymsResponse searchSynonymsResponse =  client.collections("products").synonyms().retrieve();
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Collection("products").Synonyms().Retrieve(context.Background())
 ```
 
   </template>
@@ -444,7 +483,7 @@ curl -H "X-TYPESENSE-API-KEY: ${TYPESENSE_API_KEY}" \
 ## Delete a synonym
 Delete a synonym associated with a collection.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -485,6 +524,13 @@ await client.collection('products').synonym('coat-synonyms').delete();
 
 ```java
 SearchSynonym searchSynonym = client.collections("products").synonyms("coat-synonyms").delete();
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Collection("products").Synonym("coat-synonyms").Delete(context.Background())
 ```
 
   </template>
diff --git a/docs-site/content/27.1/api/vector-search.md b/docs-site/content/27.1/api/vector-search.md
index 0f896318..e2987564 100644
--- a/docs-site/content/27.1/api/vector-search.md
+++ b/docs-site/content/27.1/api/vector-search.md
@@ -20,7 +20,7 @@ Here are some example use-cases you can build, using vector search as the founda
 4. Visual image search
 5. [Integrate with LLMs](https://python.langchain.com/docs/integrations/vectorstores/typesense), to get them to respond to queries using your own dataset (RAG)
 
-You can also combine any of the above with features like filtering, faceting, sorting, grouping, etc to build a user-friendly search experience. 
+You can also combine any of the above with features like filtering, faceting, sorting, grouping, etc to build a user-friendly search experience.
 
 ## What is an embedding?
 
@@ -29,7 +29,7 @@ An embedding for a JSON document is just an array of floating point numbers (eg:
 These embeddings are generated by Machine Learning models in such a way that documents that are "similar" to each other (for different definitions of similarity depending on the model used),
 have embeddings that are "closer" to each other (cosine similarity).
 
-Here are some common models you can use to generate these document embeddings: 
+Here are some common models you can use to generate these document embeddings:
 
 - Sentence-BERT
 - E-5
@@ -38,10 +38,10 @@ Here are some common models you can use to generate these document embeddings:
 - Google's PaLM API
 - Google's Vertex API
 
-You can import embeddings generated by these models into Typesense into a special vector field and then do a nearest neighbor search, giving another set of vectors or a document ID as the input, 
+You can import embeddings generated by these models into Typesense into a special vector field and then do a nearest neighbor search, giving another set of vectors or a document ID as the input,
 and get the documents that are closest (cosine similarity) to your input.
 
-You can also have Typesense generate these embeddings for you, using OpenAI, PaLM API or one of the built-in ML models listed [here](https://huggingface.co/typesense/models/tree/main). 
+You can also have Typesense generate these embeddings for you, using OpenAI, PaLM API or one of the built-in ML models listed [here](https://huggingface.co/typesense/models/tree/main).
 
 #### Live Demo
 
@@ -59,26 +59,26 @@ Let's now discuss how to do index and search embeddings in Typesense.
 ## Index Embeddings
 
 ### Option A: Importing externally-generated embeddings into Typesense
- 
-If you have already generated embeddings using your own models outside Typesense, you can import them into Typesense. 
+
+If you have already generated embeddings using your own models outside Typesense, you can import them into Typesense.
 
 :::tip
 [Here's](https://github.com/typesense/showcase-ecommerce-store/blob/7637d2c4e967419ac8a874c28d3f3e20d79040fa/scripts/vector-generation/main.py) a quick example of how to use the Sentence-BERT model to generate embeddings outside Typesense.
 :::
 
 Once your document embeddings are ready, you want to create a collection that contains a `float[]` field
-with a `num_dim` property for indexing them. The `num_dim` property specifies the number of 
+with a `num_dim` property for indexing them. The `num_dim` property specifies the number of
 dimensions (length of the float array) that your embeddings contain.
 
-Let's create a collection called `docs` with a vector field called `embedding` that contains just 4 dimensions. 
+Let's create a collection called `docs` with a vector field called `embedding` that contains just 4 dimensions.
 
 :::tip
-We're creating a vector with 4 dimensions in the examples to keep the code snippets readable. 
+We're creating a vector with 4 dimensions in the examples to keep the code snippets readable.
 
 Depending on what model you use, real world use will require creating vector fields with at least 256 dimensions to produce good results.
 :::
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby', 'Dart','Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby', 'Dart','Java','Go','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -220,6 +220,33 @@ collectionschema.name("docs")
                 .defaultSortingField("points");
 
 CollectionResponse collectionResponse = client.collections().create(collectionSchema);
+```
+
+  </template>
+<template v-slot:Go>
+
+```go
+schema := &api.CollectionSchema{
+  Name: "docs",
+  Fields: []api.Field{
+    {
+      Name: "title",
+      Type: "string",
+    },
+    {
+      Name: "points",
+      Type: "int32",
+    },
+    {
+      Name:   "embedding",
+      Type:   "float[]",
+      NumDim: pointer.Int(4),
+    },
+  },
+  DefaultSortingField: pointer.String("points"),
+}
+
+client.Collections().Create(context.Background(), schema)
 ```
 
   </template>
@@ -234,7 +261,7 @@ curl "http://localhost:8108/collections" \
             "name": "docs",
             "fields": [
               {"name": "title", "type": "string" },
-              {"name": "points", "type": "int32" }, 
+              {"name": "points", "type": "int32" },
               {"name": "embedding", "type": "float[]", "num_dim": 4}
             ],
             "default_sorting_field": "points"
@@ -246,7 +273,7 @@ curl "http://localhost:8108/collections" \
 
 Let's now index a document with a vector.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby', 'Dart','Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby', 'Dart','Java','Go','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -332,6 +359,24 @@ client.collection("docs").documents.create(document);
 
   </template>
 
+  <template v-slot:Go>
+
+```go
+document := struct {
+  Title     string    `json:"title"`
+  Points    int32     `json:"points"`
+  Embedding []float64 `json:"embedding"`
+}{
+  Title:     "Louvre Museuem",
+  Points:    1,
+  Embedding: []float64{0.04, 0.234, 0.113, 0.001},
+}
+
+client.Collection("docs").Documents().Create(context.Background(), document)
+```
+
+  </template>
+
   <template v-slot:Shell>
 
 ```bash
@@ -346,17 +391,17 @@ curl "http://localhost:8108/collections/docs/documents" -X POST \
 
 ### Option B: Auto-embedding generation within Typesense
 
-To simplify the process of embedding generation, Typesense can automatically use your JSON data and either OpenAI API, PaLM API or any of the built-in embedding models listed [here](https://huggingface.co/typesense/models/tree/main) to generate & store embeddings. 
+To simplify the process of embedding generation, Typesense can automatically use your JSON data and either OpenAI API, PaLM API or any of the built-in embedding models listed [here](https://huggingface.co/typesense/models/tree/main) to generate & store embeddings.
 
 When you do a search query on this automatically-generated vector field, your search query will be vectorized using the same model used for the field, which then allows you to do semantic search or combine keyword and semantic search to do hybrid search.
 
 ### Creating an auto-embedding field
 
-To create a field that automatically embeds other string or string array fields, you need to set the `embed` property of the field. 
+To create a field that automatically embeds other string or string array fields, you need to set the `embed` property of the field.
 
 Here's an example:
 
-<Tabs :tabs="['JavaScript','PHP','Python', 'Ruby', 'Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python', 'Ruby', 'Java','Go','Shell']">
 
   <template v-slot:JavaScript>
 
@@ -426,7 +471,7 @@ $schema = [
 $client->collections->create($schema);
 
 ```
-  
+
   </template>
   <template v-slot:Python>
 
@@ -464,7 +509,7 @@ client.collections.create(schema)
   </template>
 
   <template v-slot:Ruby>
-    
+
 ```rb
 
 schema = {
@@ -518,8 +563,57 @@ CollectionResponse collectionResponse = client.collections().create(collectionSc
 
   </template>
 
+  <template v-slot:Go>
+
+```go
+schema := &api.CollectionSchema{
+  Name: "products",
+  Fields: []api.Field{
+    {
+      Name: "product_name",
+      Type: "string",
+    },
+    {
+      Name: "categories",
+      Type: "string[]",
+    },
+    {
+      Name: "embedding",
+      Type: "float[]",
+      Embed: &struct {
+        From        []string "json:\"from\""
+        ModelConfig struct {
+          AccessToken  *string "json:\"access_token,omitempty\""
+          ApiKey       *string "json:\"api_key,omitempty\""
+          ClientId     *string "json:\"client_id,omitempty\""
+          ClientSecret *string "json:\"client_secret,omitempty\""
+          ModelName    string  "json:\"model_name\""
+          ProjectId    *string "json:\"project_id,omitempty\""
+        } "json:\"model_config\""
+      }{
+        From: []string{"product_name", "categories"},
+        ModelConfig: struct {
+          AccessToken  *string "json:\"access_token,omitempty\""
+          ApiKey       *string "json:\"api_key,omitempty\""
+          ClientId     *string "json:\"client_id,omitempty\""
+          ClientSecret *string "json:\"client_secret,omitempty\""
+          ModelName    string  "json:\"model_name\""
+          ProjectId    *string "json:\"project_id,omitempty\""
+        }{
+          ModelName: "ts/e5-small",
+        },
+      },
+    },
+  },
+}
+
+client.Collections().Create(context.Background(), schema)
+```
+
+  </template>
+
   <template v-slot:Shell>
-     
+
 ```bash
 curl 'http://localhost:8108/collections' \
   -X POST \
@@ -554,8 +648,8 @@ curl 'http://localhost:8108/collections' \
 
 ```
    </template>
-</Tabs>  
-     
+</Tabs>
+
 In this example the `embedding` vector field will be generated automatically while indexing a document, using the concatenated values of the `product_name` and `categories` fields (separated by spaces).
 
 ### Using Built-in Models
@@ -564,7 +658,7 @@ These models are officially supported by Typesense and stored in the Typesense H
 
 You can specify them by adding the ```ts``` namespace before the model name. Typesense will automatically download these models and make them available for use when you index documents after creating the collection.
 
-<Tabs :tabs="['JavaScript','PHP','Python', 'Ruby', 'Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python', 'Ruby', 'Java','Go','Shell']">
 
   <template v-slot:JavaScript>
 
@@ -634,7 +728,7 @@ $schema = [
 $client->collections->create($schema);
 
 ```
-  
+
   </template>
 
   <template v-slot:Python>
@@ -725,8 +819,56 @@ CollectionResponse collectionResponse = client.collections().create(collectionSc
 ```
   </template>
 
+  <template v-slot:Go>
+
+```go
+schema := &api.CollectionSchema{
+  Name: "products",
+  Fields: []api.Field{
+    {
+      Name: "brand",
+      Type: "string",
+    },
+    {
+      Name: "categories",
+      Type: "string[]",
+    },
+    {
+      Name: "embedding",
+      Type: "float[]",
+      Embed: &struct {
+        From        []string "json:\"from\""
+        ModelConfig struct {
+          AccessToken  *string "json:\"access_token,omitempty\""
+          ApiKey       *string "json:\"api_key,omitempty\""
+          ClientId     *string "json:\"client_id,omitempty\""
+          ClientSecret *string "json:\"client_secret,omitempty\""
+          ModelName    string  "json:\"model_name\""
+          ProjectId    *string "json:\"project_id,omitempty\""
+        } "json:\"model_config\""
+      }{
+        From: []string{"brand", "categories"},
+        ModelConfig: struct {
+          AccessToken  *string "json:\"access_token,omitempty\""
+          ApiKey       *string "json:\"api_key,omitempty\""
+          ClientId     *string "json:\"client_id,omitempty\""
+          ClientSecret *string "json:\"client_secret,omitempty\""
+          ModelName    string  "json:\"model_name\""
+          ProjectId    *string "json:\"project_id,omitempty\""
+        }{
+          ModelName: "ts/all-MiniLM-L12-v2",
+        },
+      },
+    },
+  },
+}
+
+client.Collections().Create(context.Background(), schema)
+```
+  </template>
+
   <template v-slot:Shell>
-     
+
 ```bash
 curl 'http://localhost:8108/collections' \
   -X POST \
@@ -761,7 +903,7 @@ curl 'http://localhost:8108/collections' \
 
 ```
    </template>
-</Tabs>  
+</Tabs>
 
 When you create a collection with the schema above, the `all-MiniLM-L12-v2` model will be downloaded and your documents will be automatically embedded by this model and will be stored in the `embedding` field.
 
@@ -770,7 +912,7 @@ If you need support for additional publicly-available models, feel free to conve
 
 ### Using a GPU (optional)
 
-Embedding models are computationally intensive to run. 
+Embedding models are computationally intensive to run.
 So when using one of the [built-in models](#using-built-in-models), you might want to consider running Typesense on a server with a GPU to improve the performance of embedding generation, especially for large datasets.
 
 #### On Typesense Cloud:
@@ -783,11 +925,11 @@ Follow the [installation guide](../../guide/install-typesense.md#using-a-gpu-opt
 
 ### Using OpenAI API
 
-You can also have Typesense send specific fields in your JSON data to OpenAI's API to generate text embeddings. 
+You can also have Typesense send specific fields in your JSON data to OpenAI's API to generate text embeddings.
 
 You can use any of OpenAI models listed [here](https://platform.openai.com/docs/guides/embeddings/embedding-models).
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Java','Go','Shell']">
 
   <template v-slot:JavaScript>
 
@@ -849,7 +991,7 @@ $schema = [
 $client->collections->create($schema);
 
 ```
-  
+
   </template>
 
   <template v-slot:Python>
@@ -934,8 +1076,53 @@ CollectionResponse collectionResponse = client.collections().create(collectionSc
 ```
   </template>
 
+  <template v-slot:Go>
+
+```go
+schema := &api.CollectionSchema{
+  Name: "products",
+  Fields: []api.Field{
+    {
+      Name: "product_name",
+      Type: "string",
+    },
+    {
+      Name: "embedding",
+      Type: "float[]",
+      Embed: &struct {
+        From        []string "json:\"from\""
+        ModelConfig struct {
+          AccessToken  *string "json:\"access_token,omitempty\""
+          ApiKey       *string "json:\"api_key,omitempty\""
+          ClientId     *string "json:\"client_id,omitempty\""
+          ClientSecret *string "json:\"client_secret,omitempty\""
+          ModelName    string  "json:\"model_name\""
+          ProjectId    *string "json:\"project_id,omitempty\""
+        } "json:\"model_config\""
+      }{
+        From: []string{"product_name"},
+        ModelConfig: struct {
+          AccessToken  *string "json:\"access_token,omitempty\""
+          ApiKey       *string "json:\"api_key,omitempty\""
+          ClientId     *string "json:\"client_id,omitempty\""
+          ClientSecret *string "json:\"client_secret,omitempty\""
+          ModelName    string  "json:\"model_name\""
+          ProjectId    *string "json:\"project_id,omitempty\""
+        }{
+          ModelName: "openai/text-embedding-ada-002",
+          ApiKey:    pointer.String("your_openai_api_key"),
+        },
+      },
+    },
+  },
+}
+
+client.Collections().Create(context.Background(), schema)
+```
+  </template>
+
   <template v-slot:Shell>
-     
+
 ```bash
 curl 'http://localhost:8108/collections' \
   -X POST \
@@ -1040,7 +1227,7 @@ $schema = [
 $client->collections->create($schema);
 
 ```
-  
+
   </template>
 
   <template v-slot:Python>
@@ -1128,7 +1315,7 @@ CollectionResponse collectionResponse = client.collections().create(collectionSc
   </template>
 
   <template v-slot:Shell>
-     
+
 ```bash
 curl 'http://localhost:8108/collections' \
   -X POST \
@@ -1166,7 +1353,7 @@ When you create the collection above, Typesense will call the OpenAI-API compati
 
 The custom API server behind the specified URL should provide the following endpoint:
 
-**Endpoint**: 
+**Endpoint**:
 
 `POST /v1/embeddings`
 
@@ -1174,7 +1361,7 @@ The custom API server behind the specified URL should provide the following endp
 
 | Parameter  | Type               | Description                  |
 |------------|--------------------|------------------------------|
-| model      | string             | Model name                   | 
+| model      | string             | Model name                   |
 | input      | string or string[] | Input string or string array |
 
 **Response Body:**
@@ -1210,7 +1397,7 @@ Response body might have additional data, but the embeddings MUST be returned in
 
 This API provided by [Google MakerSuite](https://developers.generativeai.google/products/makersuite) to generate embeddings.
 
-<Tabs :tabs="['JavaScript','PHP','Python', 'Ruby', 'Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python', 'Ruby', 'Java','Go','Shell']">
 
   <template v-slot:JavaScript>
 
@@ -1272,7 +1459,7 @@ $schema = [
 $client->collections->create($schema);
 
 ```
-  
+
   </template>
   <template v-slot:Python>
 
@@ -1350,11 +1537,57 @@ collectionschema.name("products")
                 ));
 
 CollectionResponse collectionResponse = client.collections().create(collectionSchema);
+```
+
+  </template>
+
+  <template v-slot:Go>
+
+```go
+schema := &api.CollectionSchema{
+  Name: "products",
+  Fields: []api.Field{
+    {
+      Name: "product_name",
+      Type: "string",
+    },
+    {
+      Name: "embedding",
+      Type: "float[]",
+      Embed: &struct {
+        From        []string "json:\"from\""
+        ModelConfig struct {
+          AccessToken  *string "json:\"access_token,omitempty\""
+          ApiKey       *string "json:\"api_key,omitempty\""
+          ClientId     *string "json:\"client_id,omitempty\""
+          ClientSecret *string "json:\"client_secret,omitempty\""
+          ModelName    string  "json:\"model_name\""
+          ProjectId    *string "json:\"project_id,omitempty\""
+        } "json:\"model_config\""
+      }{
+        From: []string{"product_name"},
+        ModelConfig: struct {
+          AccessToken  *string "json:\"access_token,omitempty\""
+          ApiKey       *string "json:\"api_key,omitempty\""
+          ClientId     *string "json:\"client_id,omitempty\""
+          ClientSecret *string "json:\"client_secret,omitempty\""
+          ModelName    string  "json:\"model_name\""
+          ProjectId    *string "json:\"project_id,omitempty\""
+        }{
+          ModelName: "google/embedding-gecko-001",
+          ApiKey:    pointer.String("your_google_api_key"),
+        },
+      },
+    },
+  },
+}
+
+client.Collections().Create(context.Background(), schema)
 ```
 
   </template>
   <template v-slot:Shell>
-     
+
 ```bash
 curl 'http://localhost:8108/collections' \
   -X POST \
@@ -1392,7 +1625,7 @@ curl 'http://localhost:8108/collections' \
 
 ### Using GCP Vertex AI API
 
-This API also provided by Google under the Google Cloud Platform (GCP) umbrella. 
+This API also provided by Google under the Google Cloud Platform (GCP) umbrella.
 
 You would need the following authentication information to use this method:
 
@@ -1403,7 +1636,7 @@ You would need the following authentication information to use this method:
 - GCP project ID
 
 Please refer to the Vertex AI docs for more information on how to fetch these values.
-  
+
 <Tabs :tabs="['JavaScript','PHP','Python', 'Ruby', 'Java','Shell']">
 
   <template v-slot:JavaScript>
@@ -1427,7 +1660,7 @@ schema = {
           "model_name": "gcp/embedding-gecko-001",
           "access_token": "your_gcp_access_token",
           "refresh_token": "your_gcp_refresh_token",
-          "client_id": "your_gcp_app_client_id", 
+          "client_id": "your_gcp_app_client_id",
           "client_secret": "your_gcp_client_secret",
           "project_id": "your_gcp_project_id"
         }
@@ -1462,7 +1695,7 @@ $schema = [
           "model_name" => "gcp/embedding-gecko-001",
           "access_token" => "your_gcp_access_token",
           "refresh_token" => "your_gcp_refresh_token",
-          "client_id" => "your_gcp_app_client_id", 
+          "client_id" => "your_gcp_app_client_id",
           "client_secret" => "your_gcp_client_secret",
           "project_id" => "your_gcp_project_id"
         ]
@@ -1474,7 +1707,7 @@ $schema = [
 $client->collections->create($schema);
 
 ```
-  
+
   </template>
   <template v-slot:Python>
 
@@ -1497,7 +1730,7 @@ schema = {
           "model_name": "gcp/embedding-gecko-001",
           "access_token": "your_gcp_access_token",
           "refresh_token": "your_gcp_refresh_token",
-          "client_id": "your_gcp_app_client_id", 
+          "client_id": "your_gcp_app_client_id",
           "client_secret": "your_gcp_client_secret",
           "project_id": "your_gcp_project_id"
         }
@@ -1567,7 +1800,7 @@ CollectionResponse collectionResponse = client.collections().create(collectionSc
 
   </template>
   <template v-slot:Shell>
-     
+
 ```bash
 curl 'http://localhost:8108/collections' \
   -X POST \
@@ -1591,7 +1824,7 @@ curl 'http://localhost:8108/collections' \
                 "model_name": "gcp/embedding-gecko-001",
                 "access_token": "your_gcp_access_token",
                 "refresh_token": "your_gcp_refresh_token",
-                "client_id": "your_gcp_app_client_id", 
+                "client_id": "your_gcp_app_client_id",
                 "client_secret": "your_gcp_client_secret",
                 "project_id": "your_gcp_project_id"
               }
@@ -1615,7 +1848,7 @@ You can use any of the following parameters to fine-tune how API calls are made
 | `remote_embedding_timeout_ms` | How long to wait until an API call to a remote embedding service is considered a timeout, during a search |    30s    |
 | `remote_embedding_num_tries`  | The number of times to retry an API call to a remote embedding service on failure, during a search        |     2     |
 
-<Tabs :tabs="['JavaScript','PHP','Python', 'Ruby', 'Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python', 'Ruby', 'Java','Go','Shell']">
 
   <template v-slot:JavaScript>
 
@@ -1634,7 +1867,7 @@ client.collections('products').documents().search(search_parameters)
   </template>
 
 <template v-slot:PHP>
-  
+
 ```php
 $search_parameters = [
   'q'                          => 'chair',
@@ -1650,7 +1883,7 @@ $client->collections['products']->documents->search($search_parameters);
   </template>
 
 <template v-slot:Python>
-  
+
   ```py
 search_parameters = {
   'q'                          : 'chair',
@@ -1691,11 +1924,26 @@ searchParameters.q("chair")
                 .remoteEmbeddingNumTries(3);
 
 SearchResult searchResult = client.collections("products").documents().search(searchParameters);
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+searchParameters := &api.SearchCollectionParams{
+  Q:                        pointer.String("chair"),
+  QueryBy:                  pointer.String("embedding"),
+  Prefix:                   pointer.String("false"),
+  RemoteEmbeddingTimeoutMs: pointer.Int(5000),
+  RemoteEmbeddingNumTries:  pointer.Int(3),
+}
+
+client.Collection("products").Documents().Search(context.Background(), searchParameters)
 ```
 
   </template>
   <template v-slot:Shell>
-    
+
   ```bash
 curl 'http://localhost:8108/multi_search' \
       -X POST \
@@ -1723,11 +1971,11 @@ curl 'http://localhost:8108/multi_search' \
 
 | Parameter                     | Description                                                                                                                                                                           | Default |
 |-------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------|
-| `remote_embedding_batch_size` | Max size of each batch that will be sent to remote APIs while importing multiple documents at once. Using lower amount will lower timeout risk, but increase number of requests made. | 200     |  
-| `remote_embedding_timeout_ms` | How long to wait until an API call to a remote embedding service is considered a timeout during indexing.                                                                             | 60000     |  
-| `remote_embedding_num_tries` | The number of times to retry an API call to a remote embedding service on failure during indexing.                                                                                    | 2       |  
+| `remote_embedding_batch_size` | Max size of each batch that will be sent to remote APIs while importing multiple documents at once. Using lower amount will lower timeout risk, but increase number of requests made. | 200     |
+| `remote_embedding_timeout_ms` | How long to wait until an API call to a remote embedding service is considered a timeout during indexing.                                                                             | 60000     |
+| `remote_embedding_num_tries` | The number of times to retry an API call to a remote embedding service on failure during indexing.                                                                                    | 2       |
 
-<Tabs :tabs="['JavaScript','PHP','Python', 'Ruby', 'Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python', 'Ruby', 'Java','Go','Shell']">
 
   <template v-slot:JavaScript>
 
@@ -1754,7 +2002,7 @@ $client->collections['products']->documents->import($documents, $import_paramete
   </template>
 
 <template v-slot:Python>
-  
+
   ```py
 import_parameters = {
   'remote_embedding_batch_size': 200
@@ -1766,7 +2014,7 @@ client.collections['products'].documents.import(documents, import_parameters)
   </template>
 
 <template v-slot:Ruby>
-  
+
   ```rb
 import_parameters = {
   'remote_embedding_batch_size' => 200
@@ -1785,6 +2033,17 @@ importDocumentParameters.remoteEmbeddingBatchSize(200);
 client.collections("products").documents().import(documents, importDocumentParameters);
 ```
 
+</template>
+<template v-slot:Go>
+
+```go
+importParameters := &api.ImportDocumentsParams{
+  RemoteEmbeddingBatchSize: pointer.Int(200),
+}
+
+client.Collection("products").Documents().Import(context.Background(), documents, importParameters)
+```
+
 </template>
 <template v-slot:Shell>
 
@@ -1810,7 +2069,7 @@ Create a directory under `<data_dir>/models` and store your ONNX model file, voc
 
 #### Model config file
 
-This file will contain information about the type of model you want to use. 
+This file will contain information about the type of model you want to use.
 
 The JSON file must contain `model_type` (type of the model; we support `bert` and `xlm_roberta` at the moment) and `vocab_file_name` keys.
 
@@ -1831,8 +2090,8 @@ The JSON file must contain `model_type` (type of the model; we support `bert` an
 ```
 
 Create an embedding field using the directory name as `model_name` in `model_config`.
-   
-<Tabs :tabs="['JavaScript','PHP','Python', 'Ruby', 'Java','Shell']">
+
+<Tabs :tabs="['JavaScript','PHP','Python', 'Ruby', 'Java','Go','Shell']">
 
   <template v-slot:JavaScript>
 
@@ -1888,7 +2147,7 @@ $schema = [
 $client->collections->create($schema);
 
 ```
-  
+
   </template>
   <template v-slot:Python>
 
@@ -1960,10 +2219,53 @@ collectionschema.name("products")
                 ));
 
 CollectionResponse collectionResponse = client.collections().create(collectionSchema);
+```
+  </template>
+  <template v-slot:Go>
+
+```go
+schema := &api.CollectionSchema{
+  Name: "products",
+  Fields: []api.Field{
+    {
+      Name: "product_name",
+      Type: "string",
+    },
+    {
+      Name: "embedding",
+      Type: "float[]",
+      Embed: &struct {
+        From        []string "json:\"from\""
+        ModelConfig struct {
+          AccessToken  *string "json:\"access_token,omitempty\""
+          ApiKey       *string "json:\"api_key,omitempty\""
+          ClientId     *string "json:\"client_id,omitempty\""
+          ClientSecret *string "json:\"client_secret,omitempty\""
+          ModelName    string  "json:\"model_name\""
+          ProjectId    *string "json:\"project_id,omitempty\""
+        } "json:\"model_config\""
+      }{
+        From: []string{"product_name"},
+        ModelConfig: struct {
+          AccessToken  *string "json:\"access_token,omitempty\""
+          ApiKey       *string "json:\"api_key,omitempty\""
+          ClientId     *string "json:\"client_id,omitempty\""
+          ClientSecret *string "json:\"client_secret,omitempty\""
+          ModelName    string  "json:\"model_name\""
+          ProjectId    *string "json:\"project_id,omitempty\""
+        }{
+          ModelName: "test_model",
+        },
+      },
+    },
+  },
+}
+
+client.Collections().Create(context.Background(), schema)
 ```
   </template>
   <template v-slot:Shell>
-     
+
 ```bash
 curl 'http://localhost:8108/collections' \
   -X POST \
@@ -2064,7 +2366,7 @@ $schema = [
 $client->collections->create($schema);
 
 ```
-  
+
   </template>
   <template v-slot:Python>
 
@@ -2144,7 +2446,7 @@ CollectionResponse collectionResponse = client.collections().create(collectionSc
 
   </template>
   <template v-slot:Shell>
-     
+
 ```bash
 curl 'http://localhost:8108/collections' \
   -X POST \
@@ -2188,11 +2490,11 @@ The text used to generate embeddings for the `embedding` field will be `passage:
 
 ## Nearest-neighbor vector search
 
-Once you've indexed your embeddings in a vector field, you can now search for documents that are "closest" to a given query vector. 
+Once you've indexed your embeddings in a vector field, you can now search for documents that are "closest" to a given query vector.
 
 To control the number of documents that are returned, you can either use the `per_page` pagination parameter or the `k` parameter within the vector query.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby', 'Dart','Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby', 'Dart','Java','Go','Shell']">
 <template v-slot:JavaScript>
 
 ```js
@@ -2202,7 +2504,7 @@ let searchRequests = {
       'collection': 'docs',
       'q': '*',
       'vector_query' : 'embedding:([0.96826, 0.94, 0.39557, 0.306488], k:100)', // <=== Be sure to replace `embedding` with the name of the field that stores your embeddings.
-      'exclude_fields': 'embedding', // <=== Don't return the raw floating point numbers in the vector field in the search API response, to save on network bandwidth. 
+      'exclude_fields': 'embedding', // <=== Don't return the raw floating point numbers in the vector field in the search API response, to save on network bandwidth.
     }
   ]
 }
@@ -2316,6 +2618,25 @@ commonSearchParams.put("query_by","name");
 client.multiSearch.perform(searchRequests, commonSearchParams);
 ```
 
+</template>
+<template v-slot:Go>
+
+```go
+searchRequests := api.MultiSearchSearchesParameter{
+  Searches: []api.MultiSearchCollectionParameters{
+    {
+      Collection:    "docs",
+      Q:             pointer.String("*"),
+      VectorQuery:   pointer.String("embedding:([0.96826, 0.94, 0.39557, 0.306488], k:100)"), // <=== Be sure to replace `embedding` with the name of the field that stores your embeddings.
+      ExcludeFields: pointer.String("embedding"),                                             // <=== Don't return the raw floating point numbers in the vector field in the search API response, to save on network bandwidth.
+    },
+  },
+}
+
+commonSearchParams := &api.MultiSearchParams{}
+client.MultiSearch.Perform(context.Background(), commonSearchParams, searchRequests)
+```
+
 </template>
 <template v-slot:Shell>
 
@@ -2344,7 +2665,7 @@ curl 'http://localhost:8108/multi_search' \
 NOTE: If both `per_page` and `k` parameters are provided, the larger value is used.
 
 Every matching hit in the response will contain a `vector_distance` field that indicates how "close" the document's
-vector value is to the query vector. Typesense uses the cosine similarity, so this distance will be a value between 
+vector value is to the query vector. Typesense uses the cosine similarity, so this distance will be a value between
 `0` and `2`.
 
 - If the document's vector perfectly matches the query vector, the distance will be `0`
@@ -2430,7 +2751,7 @@ curl 'http://localhost:8108/multi_search' \
 
 This will ground the vector search to fetch the closest 200 items, and then paginate within that result-set, fetching 10 results per page. You'd then increment `page` to fetch additional pages of results.
 
-We do this because, with vector search, every item in the dataset is technically a "match" to some level of closeness. So we have to limit the upper limit of closeness either using a quantity value using the `k` parameter as described above, and/or using the [`distance_threshold`](#distance-threshold) parameter of `vector_query`. 
+We do this because, with vector search, every item in the dataset is technically a "match" to some level of closeness. So we have to limit the upper limit of closeness either using a quantity value using the `k` parameter as described above, and/or using the [`distance_threshold`](#distance-threshold) parameter of `vector_query`.
 
 ## Querying for similar documents
 
@@ -2449,11 +2770,11 @@ curl 'http://localhost:8108/multi_search' \
           }
         ]
       }'
-      
+
 # Be sure to replace `embedding` with the name of the field that stores your embeddings.
 ```
 
-By specifying an empty query vector `[]` and passing an `id` parameter, this query 
+By specifying an empty query vector `[]` and passing an `id` parameter, this query
 would return all documents whose `embedding` value is closest to the `foobar` document's `embedding` value.
 
 :::tip
@@ -2466,7 +2787,7 @@ When using [auto-embedding](#option-b-auto-embedding-generation-within-typesense
 
 Typesense will use the same embedding model that was used to generate the auto-embedding field to generate vectors for the `q` parameter and then do a nearest neighbor search internally.
 
-<Tabs :tabs="['JavaScript','PHP','Python', 'Ruby', 'Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python', 'Ruby', 'Java','Go','Shell']">
 
   <template v-slot:JavaScript>
 
@@ -2521,8 +2842,8 @@ client.collections['products'].documents.search(search_parameters)
   </template>
 
 <template v-slot:Java>
-  
-  ```java 
+
+  ```java
 
 SearchParameters searchParameters = new SearchParameters();
 
@@ -2530,6 +2851,18 @@ searchParameters.q("chair")
                 .queryBy("embedding");
 
 SearchResult searchResult = client.collections("products").documents().search(searchParameters);
+```
+
+  </template>
+<template v-slot:Go>
+
+  ```go
+searchParameters := &api.SearchCollectionParams{
+    Q:       pointer.String("chair"),
+    QueryBy: pointer.String("embedding"),
+}
+
+client.Collection("products").Documents().Search(context.Background(), searchParameters)
 ```
 
   </template>
@@ -2547,7 +2880,7 @@ curl 'http://localhost:8108/multi_search' \
                 "query_by": "embedding"
               }
             ]
-          }'      
+          }'
 ```
 
   </template>
@@ -2572,7 +2905,7 @@ rank_fusion_score = 0.7 * K + 0.3 * S
 
 The `0.7` and `0.3` values can be changed using the [`alpha` parameter](#weightage-for-semantic-vs-keyword-matches).
 
-<Tabs :tabs="['JavaScript','PHP','Python', 'Ruby', 'Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python', 'Ruby', 'Java','Go','Shell']">
 
   <template v-slot:JavaScript>
 
@@ -2640,6 +2973,18 @@ searchParameters.q("chair")
                 .sortBy("_text_match:desc");
 
 SearchResult searchResult = client.collections("products").documents().search(searchParameters);
+```
+  </template>
+<template v-slot:Go>
+
+  ```go
+searchParameters := &api.SearchCollectionParams{
+    Q:       pointer.String("chair"),
+    QueryBy: pointer.String("product_name,embedding"),
+    SortBy:  pointer.String("_text_match:desc"),
+}
+
+client.Collection("products").Documents().Search(context.Background(), searchParameters)
 ```
   </template>
 
@@ -2692,13 +3037,13 @@ Typesense will do a keyword search using the `q` parameter, and a nearest neighb
 using the `vector_query` field and combine the results into a ranked set of results using rank fusion as described earlier.
 
 :::warning Performance Tip
-If you expect users to use several-words-long queries in the `q` parameter when doing hybrid search (which is common during [conversational search](./conversational-search-rag.md) for eg), 
+If you expect users to use several-words-long queries in the `q` parameter when doing hybrid search (which is common during [conversational search](./conversational-search-rag.md) for eg),
 you want to set `drop_tokens_threshold: 0` as an additional search parameter to avoid redundant internal keyword searches and excessive CPU usage. Read more about what this parameter does under [this table](./search.md#typo-tolerance-parameters).
 :::
 
 ### Weightage for Semantic vs Keyword matches
 
-By default, Typesense assigns a weight of `0.3` for vector search rank and a weight of `0.7` for keyword search rank. 
+By default, Typesense assigns a weight of `0.3` for vector search rank and a weight of `0.7` for keyword search rank.
 You can adjust the weight assigned to vector search ranking via the `alpha` option of the `vector_query` parameter.
 
 For example, to set a weight of `0.8` to vector search ranking, set `alpha` to `0.8`:
@@ -2713,7 +3058,7 @@ curl 'http://localhost:8108/multi_search' \
               "collection": "products",
               "query_by": "embedding,product_name",
               "q": "chair",
-              "vector_query": "embedding:([], alpha: 0.8)",        
+              "vector_query": "embedding:([], alpha: 0.8)",
               "exclude_fields": "embedding"
             }
           ]
@@ -2721,8 +3066,8 @@ curl 'http://localhost:8108/multi_search' \
 ```
 
 :::tip
-When querying on both an embedding field and regular search fields, some parameters like `query_by_weights` 
-won't have an impact on an embedding field mentioned in `query_by`. However, since length of `query_by_weights` 
+When querying on both an embedding field and regular search fields, some parameters like `query_by_weights`
+won't have an impact on an embedding field mentioned in `query_by`. However, since length of `query_by_weights`
 must match the length of `query_by`, you can use a placeholder value like `0`.
 :::
 
@@ -2730,7 +3075,7 @@ must match the length of `query_by`, you can use a placeholder value like `0`.
 
 You can also set a maximum vector distance threshold for results of semantic search and hybrid search. You should set `distance_threshold` in `vector_query` parameter for this.
 
-<Tabs :tabs="['JavaScript','PHP','Python', 'Ruby','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python', 'Ruby','Go','Shell']">
 
   <template v-slot:JavaScript>
 
@@ -2784,6 +3129,19 @@ search_parameters = {
 }
 
 client.collections['products'].documents.search(search_parameters)
+```
+
+  </template>
+<template v-slot:Go>
+
+  ```go
+searchParameters := &api.SearchCollectionParams{
+    Q:           pointer.String("chair"),
+    QueryBy:     pointer.String("product_name,embedding"),
+    VectorQuery: pointer.String("embedding:([], distance_threshold:0.30)"),
+}
+
+client.Collection("products").Documents().Search(context.Background(), searchParameters)
 ```
 
   </template>
@@ -2812,7 +3170,7 @@ curl 'http://localhost:8108/multi_search' \
 
 ### Sorting hybrid matches on vector distance
 
-If you want to fetch both keyword and vector search matches but sort the results only on the vector distance, 
+If you want to fetch both keyword and vector search matches but sort the results only on the vector distance,
 you can use the special sort keyword `_vector_distance`  in `sort_by`.
 
 Here's an example:
@@ -2830,13 +3188,13 @@ first on `popularity_score` and then on vector distance.
 
 ## Searching with historical queries
 
-You can send a list of search queries via the `queries` parameter to make vector search compute a weighted query embedding 
+You can send a list of search queries via the `queries` parameter to make vector search compute a weighted query embedding
 from the queries. You can use this for personalizing search results based on historical search queries.
 
-In the following example, vector search is made from the embedding calculated from the embeddings of the queries 
-`smart phone` and `apple ipad`. 
+In the following example, vector search is made from the embedding calculated from the embeddings of the queries
+`smart phone` and `apple ipad`.
 
-We can also use the optional `query_weights` parameter to assign appropriate weights to the queries. If the 
+We can also use the optional `query_weights` parameter to assign appropriate weights to the queries. If the
 `query_weights` parameter is not passed, all queries will have equal weightage.
 
 ```json
@@ -2862,14 +3220,14 @@ In the example below, we are using the vector distance as a secondary sorting co
 
 ## Brute-force searching
 
-By default, Typesense uses the built-in HNSW index to do approximate nearest neighbor vector searches. This scales 
-well for large datasets. However, if you wish to bypass the HNSW index and do a flat / brute-force ranking of 
+By default, Typesense uses the built-in HNSW index to do approximate nearest neighbor vector searches. This scales
+well for large datasets. However, if you wish to bypass the HNSW index and do a flat / brute-force ranking of
 vectors, you can do that via the `flat_search_cutoff` parameter.
 
-For example, if you wish to do brute-force vector search when a given query matches fewer than 20 documents, sending 
+For example, if you wish to do brute-force vector search when a given query matches fewer than 20 documents, sending
 `flat_search_cutoff=20` will bypass the HNSW index when the number of results found is less than 20.
 
-Here's an example where we are filtering on the `category` field and asking the vector search to use direct 
+Here's an example where we are filtering on the `category` field and asking the vector search to use direct
 flat searching if the number of results produced by the filtering operation is less than 20 results.
 
 ```shell
@@ -2882,11 +3240,11 @@ curl 'http://localhost:8108/multi_search' \
                 "collection": "docs",
                 "q": "*",
                 "filter_by": "category:shoes",
-                "vector_query": "embedding:([0.96826, 0.94, 0.39557, 0.306488], k:100, flat_search_cutoff: 20)" 
+                "vector_query": "embedding:([0.96826, 0.94, 0.39557, 0.306488], k:100, flat_search_cutoff: 20)"
               }
             ]
           }'
-          
+
 # Be sure to replace `embedding` with the name of the field that stores your embeddings.
 ```
 
@@ -2894,7 +3252,7 @@ curl 'http://localhost:8108/multi_search' \
 
 #### Indexing parameters
 
-You can set `ef_construction` (default: `200`) and `M` (default: `16`) for vector and embedding fields while creating 
+You can set `ef_construction` (default: `200`) and `M` (default: `16`) for vector and embedding fields while creating
 the collection.
 
 ```json
@@ -2951,7 +3309,7 @@ You can use each of the above parameters inside `vector_query` like this example
 - [Here's](https://hn-comments-search.typesense.org) a demo that shows you how to implement Hybrid Search (Semantic Search + Keyword Search + Filtering + Faceting) using Typesense's built-in embedding generation mechanism.
 
 - [Here's](https://ecommerce-store.typesense.org/) a demo that shows you how to implement a "Find Similar" feature using Vector Search in an ecommerce store.
-  
+
   Click on "Find Similar" below each product tile for notes on how to implement this.
 
 - [Here's](https://github.com/typesense/typesense-instantsearch-semantic-search-demo) a demo that shows you how to implement Semantic Search, using an external embeddings API and Vector Search.
diff --git a/docs-site/content/guide/building-a-search-application.md b/docs-site/content/guide/building-a-search-application.md
index 05822980..c6f68828 100644
--- a/docs-site/content/guide/building-a-search-application.md
+++ b/docs-site/content/guide/building-a-search-application.md
@@ -17,10 +17,10 @@ This should give you a file called `books.jsonl` which we'll use below.
 ## Initializing the client
 Let's begin by configuring the Typesense client by pointing it to a Typesense node.
 
-- Be sure to use the same API key that you used to [start the Typesense server](./install-typesense.md#🎬-start) earlier. 
+- Be sure to use the same API key that you used to [start the Typesense server](./install-typesense.md#🎬-start) earlier.
 - Or if you're using [Typesense Cloud](./install-typesense.md#option-1-typesense-cloud), click on the "Generate API key" button on the cluster page. This will give you a set of hostnames and API keys to use.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Java','Go','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -116,6 +116,26 @@ nodes.add(
 Configuration configuration = new Configuration(nodes, Duration.ofSeconds(2),"<API_KEY>");
 
 Client client = new Client(configuration);
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+import (
+  "github.com/typesense/typesense-go/v2/typesense"
+  "github.com/typesense/typesense-go/v2/typesense/api"
+  "github.com/typesense/typesense-go/v2/typesense/api/pointer"
+)
+
+client := typesense.NewClient(
+    typesense.WithNodes([]string{
+      // For Typesense Cloud use "https://xxx-1.a1.typesense.net:443"
+      "http://localhost:8108",
+    }),
+    typesense.WithAPIKey("<API_KEY>"),
+    typesense.WithConnectionTimeout(2*time.Second),
+)
 ```
 
   </template>
@@ -137,7 +157,7 @@ That's it - we're now ready to start interacting with the Typesense server.
 ## Creating a "books" collection
 In Typesense, a [`Collection`](../latest/api/collections.md) is a group of related [`Documents`](../latest/api/documents.md) that is roughly equivalent to a table in a relational database. When we create a collection, we give it a name and describe the fields that will be indexed when a document is added to the collection.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Java','Go','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -239,6 +259,25 @@ collectionSchema.name("books").defaultSortingField("ratings_count")
 
 CollectionResponse collectionResponse = client.collections().create(collectionSchema);
 
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+booksSchema := &api.CollectionSchema{
+  Name: "companies",
+  Fields: []api.Field{
+    {Name: "title", Type: "string"},
+    {Name: "authors", Type: "string[]", Facet: pointer.True()},
+    {Name: "publication_year", Type: "int32", Facet: pointer.True()},
+    {Name: "ratings_count", Type: "int32"},
+    {Name: "average_rating", Type: "float"},
+  },
+  DefaultSortingField: pointer.String("ratings_count"),
+}
+
+client.Collections().Create(context.Background(), booksSchema)
 ```
 
   </template>
@@ -256,7 +295,7 @@ curl "${TYPESENSE_HOST}/collections" \
 
           {"name": "publication_year", "type": "int32", "facet": true },
           {"name": "ratings_count", "type": "int32" },
-          {"name": "average_rating", "type": "float" }       
+          {"name": "average_rating", "type": "float" }
         ],
         "default_sorting_field": "ratings_count"
       }'
@@ -270,19 +309,18 @@ For each field, we define its `name, type` and whether it's a `facet` field. A f
 We also define a `default_sorting_field` that determines how the results must be sorted when no `sort_by` clause is provided. In this case, books that have more ratings will be ranked higher.
 
 :::tip Indexed fields vs un-indexed fields
-You only need to include fields that you want to search / filter / facet / sort / group_by in the collection schema. We call these indexed fields. Indexed fields are stored in RAM with a backup on disk.  
+You only need to include fields that you want to search / filter / facet / sort / group_by in the collection schema. We call these indexed fields. Indexed fields are stored in RAM with a backup on disk.
 
-You can still send additional fields that you might use for display purposes (for eg: image URLs) when importing the documents into Typesense. 
-Any fields not mentioned in the schema, but present in an imported document, will only be stored on disk and returned when the document is a hit. 
+You can still send additional fields that you might use for display purposes (for eg: image URLs) when importing the documents into Typesense.
+Any fields not mentioned in the schema, but present in an imported document, will only be stored on disk and returned when the document is a hit.
 We call these un-indexed fields and this helps conserve memory usage and avoid wasted CPU cycles in trying to otherwise build unused indices for these fields in memory.
 :::
 
-
 ## Adding books to the collection
 
 We're now ready to index some books into the collection we just created.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Java','Go','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -324,6 +362,20 @@ collections['books'].documents.import(books_data)
 ```java
 String booksData = Files.readString("/tmp/books.jsonl");
 client.collections("books").documents().import_(booksData)
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+params := &api.ImportDocumentsParams{
+  Action:    pointer.String("create"),
+  BatchSize: pointer.Int(40),
+}
+importBody, err := os.Open("/tmp/books.jsonl")
+// defer close, error handling ...
+
+client.Collection("books").Documents().ImportJsonl(context.Background(), importBody, params)
 ```
 
   </template>
@@ -342,8 +394,7 @@ curl "${TYPESENSE_HOST}/collections/books/documents/import" \
 ## Searching for books
 We will start with a really simple search query - let's search for `harry potter` and ask Typesense to rank books that have more ratings higher in the results.
 
-
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Java','Go','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -410,6 +461,19 @@ SearchParameters searchParameters = new SearchParameters()
                                                 .addQueryByItem("title")
                                                 .addSortByItem("ratings_count:desc");
 SearchResult searchResult = client.collections("books").documents().search(searchParameters);
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+searchParameters := &api.SearchCollectionParams{
+  Q:        pointer.String("harry potter"),
+  QueryBy:  pointer.String("title"),
+  SortBy:   &([]string{"ratings_count:desc"}),
+}
+
+client.Collection("books").Documents().Search(context.Background(), searchParameters)
 ```
 
   </template>
@@ -477,7 +541,7 @@ Read more about Semantic Search in the dedicated guide article [here](./semantic
 ## Filtering results
 Now, let's tweak our query to only fetch books that are published before the year 1998. To do that, we just have to add a `filter_by` clause to our query:
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Java','Go','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -549,6 +613,20 @@ SearchParameters searchParameters = new SearchParameters()
                                                 .filterBy("publication_year:<1998")
                                                 .addSortByItem("ratings_count:desc");
 SearchResult searchResult = client.collections("books").documents().search(searchParameters);
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+searchParameters := &api.SearchCollectionParams{
+  Q:        pointer.String("harry potter"),
+  QueryBy:  pointer.String("title"),
+  FilterBy: pointer.String("publication_year:<1998"),
+  SortBy:   &([]string{"publication_year:desc"}),
+}
+
+client.Collection("companies").Documents().Search(context.Background(), searchParameters)
 ```
 
   </template>
@@ -605,8 +683,7 @@ curl -H "X-TYPESENSE-API-KEY: ${TYPESENSE_API_KEY}" \
 ## Faceting
 Let's facet the search results by the authors field to see how that works. Let's also use this example to see how Typesense handles typographic errors. Let's search for `experyment` (notice the typo!).
 
-
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Java','Go','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -678,6 +755,20 @@ SearchParameters searchParameters = new SearchParameters()
                                                 .addFacetByItem("authors_facet")
                                                 .addSortByItem("average_rating:desc");
 SearchResult searchResult = client.collections("books").documents().search(searchParameters);
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+searchParameters := &api.SearchCollectionParams{
+  Q:        pointer.String("experyment"),
+  QueryBy:  pointer.String("title"),
+  FacetBy:  pointer.String("authors"),
+  SortBy:   &([]string{"average_rating:desc"}),
+}
+
+client.Collection("companies").Documents().Search(context.Background(), searchParameters)
 ```
 
   </template>
diff --git a/docs-site/content/guide/high-availability.md b/docs-site/content/guide/high-availability.md
index c99736f1..ac200d47 100644
--- a/docs-site/content/guide/high-availability.md
+++ b/docs-site/content/guide/high-availability.md
@@ -1,11 +1,11 @@
 # High Availability
 
-You can run a cluster of Typesense nodes for high availability. 
+You can run a cluster of Typesense nodes for high availability.
 Typesense uses the Raft consensus algorithm to manage the cluster and recover from node failures.
 
-In cluster mode, Typesense will automatically replicate your entire dataset to all nodes in the cluster, automatically and continuously. 
-Read and write API calls can be sent to any nodes in the cluster - 
-read API calls will be served by the node that receives it, write API calls are automatically forwarded to the leader of the cluster internally. 
+In cluster mode, Typesense will automatically replicate your entire dataset to all nodes in the cluster, automatically and continuously.
+Read and write API calls can be sent to any nodes in the cluster -
+read API calls will be served by the node that receives it, write API calls are automatically forwarded to the leader of the cluster internally.
 
 Since Raft requires a quorum for consensus, you need to run a ***minimum of 3 nodes*** to tolerate a 1-node failure. Running a 5-node cluster will tolerate failures of up to 2 nodes, but at the expense of slightly higher write latencies.
 
@@ -13,9 +13,9 @@ Since Raft requires a quorum for consensus, you need to run a ***minimum of 3 no
 
 ## High Availability in Typesense Cloud
 
-In [Typesense Cloud](https://cloud.typesense.org), we manage High Availability for you. 
+In [Typesense Cloud](https://cloud.typesense.org), we manage High Availability for you.
 
-When you flip the setting ON when launching a cluster, you'll see a special Load Balanced endpoint in addition to the individual hostnames*, in your cluster dashboard: 
+When you flip the setting ON when launching a cluster, you'll see a special Load Balanced endpoint in addition to the individual hostnames*, in your cluster dashboard:
 
 <img src="~@images/high-availability/ha-hostnames.png" height="350" width="367" alt="Typesense Cloud HA Hostnames">
 
@@ -24,7 +24,7 @@ If a particular node has an infrastructure issue, or is inaccessible for any rea
 
 ::: warning *Note
 
-You will only see the Load Balanced endpoint for HA clusters provisioned after **June 16, 2022**. 
+You will only see the Load Balanced endpoint for HA clusters provisioned after **June 16, 2022**.
 
 For HA clusters provisioned **before June 16, 2022**, you will only see the individual hostnames. Health-checking and traffic re-routing are done client-side in our official client libraries.
 See [Client Configuration](#client-configuration) below. If you'd like to enable server-side load-balancing for your existing clusters, please reach out to us at support at typesense d0t org with your Cluster ID.
@@ -135,7 +135,7 @@ typesense-server \
 
 - `--api-address` can be a public or private IP address. This is the IP address that your end users/clients will connect to interact with the Typesense API.
 
-- We strongly recommend setting `--api-port` to 443 (HTTPS) in a production setting, and configuring SSL certs using the `--ssl-certificate` and `--ssl-certificate-key` server parameters. 
+- We strongly recommend setting `--api-port` to 443 (HTTPS) in a production setting, and configuring SSL certs using the `--ssl-certificate` and `--ssl-certificate-key` server parameters.
 :::
 
 :::tip
@@ -174,13 +174,13 @@ All the other nodes should return a response of:
 
 where `state: 4` indicates that the node was selected to be a follower.
 
-If you see `state: 1` on more than one node, that indicates that the cluster was not formed properly. Check the Typesense logs (usually in `/var/log/typesense/typesense.log`) for more diagnostic information. Ensure that the nodes can talk to each other on the ports you've configured as the HTTP port and the Peering port. 
+If you see `state: 1` on more than one node, that indicates that the cluster was not formed properly. Check the Typesense logs (usually in `/var/log/typesense/typesense.log`) for more diagnostic information. Ensure that the nodes can talk to each other on the ports you've configured as the HTTP port and the Peering port.
 
 If you see a value other than `state: 4` or `state: 1` that indicates an error. Check the Typesense logs (usually in `/var/log/typesense/typesense.log`) for more diagnostic information.
 
 ### Recovering a cluster that has lost quorum
 
-A Typesense cluster with N nodes can tolerate a failure of at most `(N-1)/2` nodes without affecting reads or writes. 
+A Typesense cluster with N nodes can tolerate a failure of at most `(N-1)/2` nodes without affecting reads or writes.
 
 So for example:
 
@@ -206,7 +206,7 @@ and it will load balance reads & writes across all nodes and will automatically
 
 Here's a sample 3-node client configuration:
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby', 'Dart', 'Java', 'Swift', 'Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby', 'Dart', 'Java', 'Go', 'Swift', 'Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -239,7 +239,7 @@ use Typesense\Client;
 
 $client = new Client(
   [
-    'nodes' => [ 
+    'nodes' => [
       ['host' => 'typesense-1.example.net', 'port' => '443', 'protocol' => 'https'],
       ['host' => 'typesense-2.example.net', 'port' => '443', 'protocol' => 'https'],
       ['host' => 'typesense-3.example.net', 'port' => '443', 'protocol' => 'https'],
@@ -327,6 +327,27 @@ nodes.add(new Node("https", "typesense-3.example.net", "443"));
 Configuration configuration = new Configuration(nodes, Duration.ofSeconds(2),"<API_KEY>");
 
 Client client = new Client(configuration);
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+import (
+  "github.com/typesense/typesense-go/v2/typesense"
+  "github.com/typesense/typesense-go/v2/typesense/api"
+  "github.com/typesense/typesense-go/v2/typesense/api/pointer"
+)
+
+client := typesense.NewClient(
+    typesense.WithNodes([]string{
+      "https://xxx-1.a1.typesense.net:443",
+      "https://xxx-2.a1.typesense.net:443",
+      "https://xxx-3.a1.typesense.net:443",
+    }),
+    typesense.WithAPIKey("<API_KEY>"),
+    typesense.WithConnectionTimeout(2*time.Second),
+)
 ```
 
   </template>
@@ -358,11 +379,11 @@ export TYPESENSE_HOST='https://typesense.example.net'
 
 ### When using Typesense Cloud or a Load Balancer
 
-If you use Typesense Cloud (with load-balancing enabled on your cluster, which is enabled by default for all clusters provisioned after June 16, 2022), or if you choose to set up a server-side load-balancer for convenience, you want to specify the load-balanced endpoint where all requests are routed to by default, by the client. 
+If you use Typesense Cloud (with load-balancing enabled on your cluster, which is enabled by default for all clusters provisioned after June 16, 2022), or if you choose to set up a server-side load-balancer for convenience, you want to specify the load-balanced endpoint where all requests are routed to by default, by the client.
 
-In Typesense Cloud, you also want to specify the individual hostnames in addition - these are used as fallback nodes by the client, in case the load-balanced endpoint hits a stale node that is currently in a "connection-draining" status just as a node rotation happens (lasts 30s per node rotation, for eg during a configuration change or infrastructure update). 
+In Typesense Cloud, you also want to specify the individual hostnames in addition - these are used as fallback nodes by the client, in case the load-balanced endpoint hits a stale node that is currently in a "connection-draining" status just as a node rotation happens (lasts 30s per node rotation, for eg during a configuration change or infrastructure update).
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby', 'Dart', 'Java', 'Swift', 'Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby', 'Dart', 'Java', 'Go', 'Swift', 'Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -397,7 +418,7 @@ use Typesense\Client;
 $client = new Client(
   [
     'nearest_node' =>  ['host' => 'xxx.a1.typesense.net', 'port' => '443', 'protocol' => 'https'], // This is the special Load Balanced hostname that you'll see in the Typesense Cloud dashboard if you turn on High Availability
-    'nodes' => [ 
+    'nodes' => [
       ['host' => 'xxx-1.a1.typesense.net', 'port' => '443', 'protocol' => 'https'],
       ['host' => 'xxx-2.a1.typesense.net', 'port' => '443', 'protocol' => 'https'],
       ['host' => 'xxx-3.a1.typesense.net', 'port' => '443', 'protocol' => 'https'],
@@ -500,6 +521,29 @@ Node nearestNode = new Node("https", "xxx.a1.typesense.net", "443");
 Configuration configuration = new Configuration(nearestNode, nodes, Duration.ofSeconds(2),"<API_KEY>");
 
 Client client = new Client(configuration);
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+import (
+  "github.com/typesense/typesense-go/v2/typesense"
+  "github.com/typesense/typesense-go/v2/typesense/api"
+  "github.com/typesense/typesense-go/v2/typesense/api/pointer"
+)
+
+client := typesense.NewClient(
+    // This is the special Load Balanced hostname that you'll see in the Typesense Cloud dashboard if you turn on High Availability
+    typesense.WithNearestNode("https://xxx.a1.typesense.net:443"),
+    typesense.WithNodes([]string{
+      "https://xxx-1.a1.typesense.net:443",
+      "https://xxx-2.a1.typesense.net:443",
+      "https://xxx-3.a1.typesense.net:443",
+    }),
+    typesense.WithAPIKey("<API_KEY>"),
+    typesense.WithConnectionTimeout(2*time.Second),
+)
 ```
 
   </template>
@@ -531,4 +575,4 @@ export TYPESENSE_HOST='https://xxx.a1.typesense.net'
   </template>
 </Tabs>
 
-Here `xxx.a1.typesense.net` is a Load Balanced endpoint. 
\ No newline at end of file
+Here `xxx.a1.typesense.net` is a Load Balanced endpoint.
\ No newline at end of file
diff --git a/docs-site/content/guide/installing-a-client.md b/docs-site/content/guide/installing-a-client.md
index ffa55719..870e677f 100644
--- a/docs-site/content/guide/installing-a-client.md
+++ b/docs-site/content/guide/installing-a-client.md
@@ -23,7 +23,7 @@ We also have the following community-maintained client libraries:
 ---
 - <RouterLink :to="`/${$site.themeConfig.typesenseLatestVersion}/api/api-clients.html#framework-integrations`">Other Framework Integrations</RouterLink>
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart', 'Java', 'Swift']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart', 'Java','Go','Swift']">
   <template v-slot:JavaScript>
 
 ```js
@@ -78,13 +78,26 @@ import 'package:typesense/typesense.dart';
   <template v-slot:Java>
 
 ```java
-// Download the JAR file from the releases section in the typesense-java repository. 
+// Download the JAR file from the releases section in the typesense-java repository.
 // (https://github.com/typesense/typesense-java/releases)
 // And the import it them to your project
 
 import org.typesense.api.*;
 import org.typesense.models.*;
 import org.typesense.resources.*;
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+// $ go get github.com/typesense/typesense-go/v2/typesense
+
+import (
+  "github.com/typesense/typesense-go/v2/typesense"
+  "github.com/typesense/typesense-go/v2/typesense/api"
+  "github.com/typesense/typesense-go/v2/typesense/api/pointer"
+)
 ```
 
   </template>
diff --git a/docs-site/content/guide/typesense-cloud/search-delivery-network.md b/docs-site/content/guide/typesense-cloud/search-delivery-network.md
index 0bbd1291..c8a33175 100644
--- a/docs-site/content/guide/typesense-cloud/search-delivery-network.md
+++ b/docs-site/content/guide/typesense-cloud/search-delivery-network.md
@@ -1,6 +1,6 @@
 # Search Delivery Network
 
-**In Typesense Cloud**, you can choose to have your data distributed to multiple regions around the world 
+**In Typesense Cloud**, you can choose to have your data distributed to multiple regions around the world
 and have search queries routed to the node that's closest to where your end users are geographically located.
 We call this a Search Delivery Network (SDN).
 
@@ -25,7 +25,7 @@ Typesense Cloud has 20+ geo regions around the world, and you can pick any 3-5 r
 
 When you provision a Typesense Cloud cluster, you'll find the option to turn on "Search Delivery Network" in the cluster configuration page, and select the regions you want in your SDN.
 
-Once the cluster is provisioned, you'll now see a special "Nearest Node" hostname displayed in the dashboard: 
+Once the cluster is provisioned, you'll now see a special "Nearest Node" hostname displayed in the dashboard:
 
 <img src="~@images/search-delivery-network/sdn-hostnames.png" height="350" width="385" alt="Typesense Cloud SDN Hostnames">
 
@@ -37,7 +37,7 @@ The official client libraries support specifying a nearest node hostname, and th
 
 Requests are first sent to the Nearest Node endpoint, and if it fails for some reason, the request is then retried on the fallback nodes in a round-robin fashion.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby', 'Dart', 'Java', 'Swift', 'Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby', 'Dart', 'Java', 'Go', 'Swift', 'Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -72,7 +72,7 @@ use Typesense\Client;
 $client = new Client(
   [
     'nearest_node' =>  ['host' => 'xxx.a1.typesense.net', 'port' => '443', 'protocol' => 'https'], // This is the special Nearest Node hostname that you'll see in the Typesense Cloud dashboard if you turn on Search Delivery Network
-    'nodes' => [ 
+    'nodes' => [
       ['host' => 'xxx-1.a1.typesense.net', 'port' => '443', 'protocol' => 'https'],
       ['host' => 'xxx-2.a1.typesense.net', 'port' => '443', 'protocol' => 'https'],
       ['host' => 'xxx-3.a1.typesense.net', 'port' => '443', 'protocol' => 'https'],
@@ -175,6 +175,28 @@ Node nearestNode = new Node("https", "xxx.a1.typesense.net", "443");
 Configuration configuration = new Configuration(nearestNode, nodes, Duration.ofSeconds(2),"<API_KEY>");
 
 Client client = new Client(configuration);
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+import (
+  "time"
+  "github.com/typesense/typesense-go/v2/typesense"
+)
+
+client := typesense.NewClient(
+    // This is the special Load Balanced hostname that you'll see in the Typesense Cloud dashboard if you turn on High Availability
+    typesense.WithNearestNode("https://xxx.a1.typesense.net:443"),
+    typesense.WithNodes([]string{
+      "https://xxx-1.a1.typesense.net:443",
+      "https://xxx-2.a1.typesense.net:443",
+      "https://xxx-3.a1.typesense.net:443",
+    }),
+    typesense.WithAPIKey("<API_KEY>"),
+    typesense.WithConnectionTimeout(2*time.Second),
+)
 ```
 
   </template>
@@ -208,15 +230,15 @@ export TYPESENSE_HOST='https://xxx.a1.typesense.net'
 
 ::: warning NOTE
 
-For Typesense Cloud SDN clusters provisioned **after Jun 16, 2022**,  
+For Typesense Cloud SDN clusters provisioned **after Jun 16, 2022**,
 if a particular region has infrastructure issues, or a node is in accessible for any reason,
-traffic is automatically re-routed to the next closest node that is healthy server-side. 
-So specifying fallback nodes in the client configuration is optional (but still recommended when a client library supports it), as traffic re-routing in error scenarios happens on the server-side. 
+traffic is automatically re-routed to the next closest node that is healthy server-side.
+So specifying fallback nodes in the client configuration is optional (but still recommended when a client library supports it), as traffic re-routing in error scenarios happens on the server-side.
 
 In Typesense Cloud SDN clusters provisioned **before Jun 16, 2022**,
 the nearest node endpoint will resolve to the node that's closest to the user, regardless of whether the node is healthy or not.
 So you would have to rely on client-side load-balancing and the fallback nodes mentioned above to route requests away from unhealthy nodes.
-In this case, specifying both the nearest node and fallback node is required in the client libraries.  
+In this case, specifying both the nearest node and fallback node is required in the client libraries.
 
 If you'd like to enable automatic re-routing (server-side load-balancing) for your existing SDN cluster provisioned before Jun 16, 2022, you can do that by going to your Cluster Dashboard > Cluster Configuration > Modify and then enable "Load Balancing" and schedule the change.
 :::

From 556284557174e95b6c78550a1919468b310b27e3 Mon Sep 17 00:00:00 2001
From: Hayden <hayden.hhoang@gmail.com>
Date: Fri, 18 Oct 2024 22:01:55 +0700
Subject: [PATCH 2/3] docs(go): documents API

---
 docs-site/content/27.1/api/documents.md | 203 ++++++++++++++++++++----
 1 file changed, 170 insertions(+), 33 deletions(-)

diff --git a/docs-site/content/27.1/api/documents.md b/docs-site/content/27.1/api/documents.md
index 07fca0fc..37cf8bb1 100644
--- a/docs-site/content/27.1/api/documents.md
+++ b/docs-site/content/27.1/api/documents.md
@@ -12,7 +12,7 @@ Every record you index in Typesense is called a `Document`.
 
 A document to be indexed in a given collection must conform to the [schema of the collection](./collections.md#create-a-collection).
 
-If the document contains an `id` field of type `string`, Typesense will use that field as the identifier for the document. 
+If the document contains an `id` field of type `string`, Typesense will use that field as the identifier for the document.
 Otherwise, Typesense will assign an auto-generated identifier to the document. Since it's a special field, the `id` field
 is not required to be defined as part of the collection schema.
 
@@ -25,11 +25,11 @@ The `id` should not include spaces or any other characters that require [encodin
 If you need to index a document in response to some user action in your application, you can use the single document create endpoint.
 
 If you need to index multiple documents at a time, we highly recommend using the [import documents](#index-multiple-documents) endpoint, which is optimized for bulk imports.
-For eg: If you have 100 documents, indexing them using the import endpoint at once will be much more performant than indexing documents one a time. 
+For eg: If you have 100 documents, indexing them using the import endpoint at once will be much more performant than indexing documents one a time.
 
 Let's see how we can add a new document to a collection.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby', 'Dart', 'Java', 'Swift', 'Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby', 'Dart', 'Java', 'Go','Swift', 'Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -111,6 +111,25 @@ document.put("num_employees",5215);
 document.put("country","USA");
 
 client.collections("companies").documents().create(document);
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+document := struct {
+  ID           string `json:"id"`
+  CompanyName  string `json:"company_name"`
+  NumEmployees int    `json:"num_employees"`
+  Country      string `json:"country"`
+}{
+  ID:           "124",
+  CompanyName:  "Stark Industries",
+  NumEmployees: 5215,
+  Country:      "USA",
+}
+
+client.Collection("companies").Documents().Create(context.Background(), document)
 ```
 
   </template>
@@ -162,7 +181,7 @@ We can also replace a document with the same `id` if it already exists, or creat
 If you need to upsert multiple documents at a time, we highly recommend using the [import documents](#index-multiple-documents) endpoint with `action=upsert`, which is optimized for bulk upserts.
 For eg: If you have 100 documents, upserting them using the import endpoint at once will be much more performant than upserting documents one a time.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby', 'Dart', 'Java', 'Swift', 'Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby', 'Dart', 'Java', 'Go', 'Swift', 'Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -245,6 +264,25 @@ dpocument.put("num_employees",5215);
 document.put("country","USA");
 
 client.collections("companies").documents().upsert(document);
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+document := struct {
+  ID           string `json:"id"`
+  CompanyName  string `json:"company_name"`
+  NumEmployees int    `json:"num_employees"`
+  Country      string `json:"country"`
+}{
+  ID:           "123",
+  CompanyName:  "Stark Industries",
+  NumEmployees: 5215,
+  Country:      "USA",
+}
+
+client.Collection("companies").Documents().Upsert(context.Background(), document)
 ```
 
   </template>
@@ -319,11 +357,11 @@ This is essentially one JSON object per line, without commas between documents.
 
 If you are using one of our client libraries, you can also pass in an array of documents and the library will take care of converting it into JSONL.
 
-You can also [convert from CSV to JSONL](#import-a-csv-file) and [JSON to JSONL](#import-a-json-file) before importing to Typesense. 
+You can also [convert from CSV to JSONL](#import-a-csv-file) and [JSON to JSONL](#import-a-json-file) before importing to Typesense.
 
 #### Action modes (create, upsert, update & emplace)
 
-Besides batch-creating documents, you can also use the `action` query parameter to update documents using 
+Besides batch-creating documents, you can also use the `action` query parameter to update documents using
 their `id` field.
 
 <table>
@@ -333,12 +371,12 @@ their `id` field.
     </tr>
     <tr>
         <td>upsert</td>
-        <td>Creates a new document or updates an existing document if a document with the same <code>id</code> already exists. 
+        <td>Creates a new document or updates an existing document if a document with the same <code>id</code> already exists.
            Requires the whole document to be sent. For partial updates, use the <code>update</code> action below.</td>
     </tr>
     <tr>
         <td>update	</td>
-        <td>Updates an existing document. Fails if a document with the given <code>id</code> does not exist. You can send 
+        <td>Updates an existing document. Fails if a document with the given <code>id</code> does not exist. You can send
             a partial document containing only the fields that are to be updated.</td>
     </tr>
     <tr>
@@ -350,7 +388,7 @@ their `id` field.
 
 Let's see how we can now use the `create` mode to import some documents.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -459,6 +497,34 @@ importDocumentsParameters.action("create");
 //  when instantiating the client
 
 client.collections("Countries").documents().import_(documentList, importDocumentsParameters);
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+documents := []interface{}{
+  struct {
+    ID           string `json:"id"`
+    CompanyName  string `json:"companyName"`
+    NumEmployees int    `json:"numEmployees"`
+    Country      string `json:"country"`
+  }{
+    ID:           "124",
+    CompanyName:  "Stark Industries",
+    NumEmployees: 5215,
+    Country:      "USA",
+  },
+}
+
+params := &api.ImportDocumentsParams{
+  Action:    pointer.String("create"),
+}
+
+// IMPORTANT: Be sure to increase connectionTimeoutSeconds to at least 5 minutes or more for imports,
+//  when instantiating the client
+
+client.Collection("companies").Documents().Import(context.Background(), documents, params)
 ```
 
   </template>
@@ -572,11 +638,11 @@ Likewise, using the `return_doc` parameter will return the entire document back
 By default, Typesense ingests 40 documents at a time into Typesense - after every 40 documents are ingested, Typesense will then service the search request queue, before switching back to imports.
 To increase this value, use the `batch_size` parameter.
 
-Note that this parameter controls server-side batching of documents sent in a single import API call. 
+Note that this parameter controls server-side batching of documents sent in a single import API call.
 Increasing this value might affect search performance, so we'd recommend that you not change the default unless you really need to.
 You can also do client-side batching, by sending your documents over multiple import API calls (potentially in parallel).
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -632,6 +698,19 @@ ImportDocumentsParameters queryParameters = new ImportDocumentsParameters();
 queryParameters.batchSize(100);
 
 client.collections("companies").documents().import_(documentsInJsonl, queryParameters)
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+params := &api.ImportDocumentsParams{
+  BatchSize: pointer.Int(100),
+}
+documentsInJsonl, err := os.Open("documents.jsonl")
+// defer close, error handling ...
+
+client.Collection("companies").Documents().ImportJsonl(context.Background(), documentsInJsonl, params)
 ```
 
   </template>
@@ -712,7 +791,7 @@ client.collections['titles'].documents.create(document, {
 
 ```rb
 document = {'title'  => 1984, 'points' => 100}
-client.collections['titles'].documents.create(document, 
+client.collections['titles'].documents.create(document,
     dirty_values: 'coerce_or_reject'
 )
 ```
@@ -782,7 +861,7 @@ To do that, we can define a schema as follows:
     {"name": ".*", "type": "string*" }
   ]
 }
-``` 
+```
 
 Now, Typesense will automatically convert any single/multi-valued data into their corresponding string
 representations automatically when data is indexed with the `dirty_values: "coerce_or_reject"` mode.
@@ -833,7 +912,7 @@ Here's an example file:
 
 You can import the above `documents.jsonl` file like this.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -888,6 +967,19 @@ while (myReader.hasNextLine()) {
     data.append(myReader.nextLine()).append("\n");
 }
 client.collections("books").documents().import_(data.toString(), queryParameters);
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+params := &api.ImportDocumentsParams{
+  Action: pointer.String("create"),
+}
+documentsInJsonl, err := os.Open("documents.jsonl")
+// defer close, error handling ...
+
+client.Collection("companies").Documents().ImportJsonl(context.Background(), documentsInJsonl, params)
 ```
 
   </template>
@@ -909,8 +1001,8 @@ curl -H "X-TYPESENSE-API-KEY: ${TYPESENSE_API_KEY}" \
       -T documents.jsonl \
       "http://localhost:8108/collections/companies/documents/import?action=create"
 
-# If you have a large JSONL file, 
-#   you can split the file and 
+# If you have a large JSONL file,
+#   you can split the file and
 #   parallelize the import using this one liner:
 parallel --block -5 -a documents.jsonl --tmpdir /tmp --pipepart --cat 'curl -H "X-TYPESENSE-API-KEY: ${TYPESENSE_API_KEY}" -X POST -T {} http://localhost:8108/collections/companies/documents/import?action=create'
 ```
@@ -942,12 +1034,12 @@ Once you have the JSONL file, you can then import it following the [instructions
 
 ### Import other file types
 
-Typesense is primarily a JSON store, optimized for fast search. 
+Typesense is primarily a JSON store, optimized for fast search.
 So if you can extract data from other file types and convert it into structured JSON, you can import it into Typesense and search through it.
 
-For eg, here's one library you can use to [convert DOCX files to JSON](https://github.com/microsoft/Simplify-Docx). 
+For eg, here's one library you can use to [convert DOCX files to JSON](https://github.com/microsoft/Simplify-Docx).
 
-[Apache Tika](https://tika.apache.org/) is another library to extract text and metadata from PDF, PPT, XLS and over a 1000 different file formats. 
+[Apache Tika](https://tika.apache.org/) is another library to extract text and metadata from PDF, PPT, XLS and over a 1000 different file formats.
 
 Once you've extracted the JSON, you can then [index](#index-documents) them in Typesense just like any other JSON file.
 
@@ -956,7 +1048,7 @@ Once you've extracted the JSON, you can then [index](#index-documents) them in T
 
 Fetch an individual document from a collection by using its `id`.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -997,6 +1089,13 @@ await client.collection('companies').document('124').retrieve();
 
 ```java
 Hashmap<String, Object> document = client.collections("companies").documents("124").retrieve();
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Collection("companies").Document("124").Retrieve(context.Background())
 ```
 
   </template>
@@ -1049,15 +1148,15 @@ While retrieving a document, you can use the following parameters to control the
 
 ## Update documents
 
-Typesense allows you to update a single document, multiple documents, or documents that match a particular 
+Typesense allows you to update a single document, multiple documents, or documents that match a particular
 `filter_by` query.
 
 ### Update a single document
 
-We can update a single document from a collection by using its `id`. The update can be partial, 
+We can update a single document from a collection by using its `id`. The update can be partial,
 as shown below:
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -1123,10 +1222,25 @@ await client.collection('companies').document('124').update(document);
 
 ```java
 HashMap<String, Object> document = new HashMap<>();
-document.put("company_name","Stark Industries"); 
+document.put("company_name","Stark Industries");
 document.put("num_employees",5500);
 
-HashMap<String, Object> updatedDocument = client.collections("companies").documents("124").update(document) 
+HashMap<String, Object> updatedDocument = client.collections("companies").documents("124").update(document)
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+document := struct {
+  CompanyName  string `json:"company_name"`
+  NumEmployees int    `json:"num_employees"`
+}{
+  CompanyName:  "Stark Industries",
+  NumEmployees: 5500,
+}
+
+client.Collection("companies").Document("124").Update(context.Background(), document)
 ```
 
   </template>
@@ -1181,7 +1295,7 @@ curl "http://localhost:8108/collections/companies/documents/124" -X PATCH \
 ### Update multiple documents
 
 To update multiple documents, use the import endpoint with [`action=update`](#action-modes-batch-create-upsert-update-emplace),
-[`action=upsert`](#action-modes-batch-create-upsert-update-emplace) or [`action=emplace`](#action-modes-batch-create-upsert-update-emplace). 
+[`action=upsert`](#action-modes-batch-create-upsert-update-emplace) or [`action=emplace`](#action-modes-batch-create-upsert-update-emplace).
 
 ### Update by query
 
@@ -1248,11 +1362,11 @@ await client.collection('companies').document.update(document, {filter_by: 'num_
 
 ```java
 HashMap<String, Object> document = new HashMap<>();
-document.put("tag","large"); 
+document.put("tag","large");
 UpdateDocumentsParameters updateDocumentsParameters = new UpdateDocumentsParameters();
 updateDocumentsParameters.filterBy("num_employees:>1000");
 
-HashMap<String, Object> updatedDocument = client.collections("companies").documents().update(document, updateDocumentsParameters) 
+HashMap<String, Object> updatedDocument = client.collections("companies").documents().update(document, updateDocumentsParameters)
 ```
 
 </template>
@@ -1293,7 +1407,7 @@ curl "http://localhost:8108/collections/companies/documents?filter_by=num_employ
 
 Delete an individual document from a collection by using its `id`.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -1334,6 +1448,13 @@ await client.collection('companies').document('124').delete();
 
 ```java
 HashMap<String, Object> deletedDocument = client.collections("companies").documents("124").delete();
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Collection("companies").Document("124").Delete(context.Background())
 ```
 
   </template>
@@ -1355,7 +1476,7 @@ curl -H "X-TYPESENSE-API-KEY: ${TYPESENSE_API_KEY}" -X DELETE \
   </template>
 </Tabs>
 
-**NOTE:** When a document does not exist for the given `id`, an error is returned. To ignore this error and treat the 
+**NOTE:** When a document does not exist for the given `id`, an error is returned. To ignore this error and treat the
 deletion as success, you can send `ignore_not_found=true` parameter.
 
 **Sample Response**
@@ -1383,7 +1504,7 @@ deletion as success, you can send `ignore_not_found=true` parameter.
 
 You can also delete a bunch of documents that match a specific [`filter_by`](search.md#filter-results) condition:
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -1427,6 +1548,15 @@ DeleteDocumentsParameters deleteDocumentsParameters = new DeleteDocumentsParamet
 deleteDocumentsParameters.filterBy("num_employees:>100");
 
 client.collections("companies").documents().delete(deleteDocumentsParameters);
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Collection("companies").Documents().Delete(context.Background(), &api.DeleteDocumentsParams{
+  FilterBy: pointer.String("num_employees:>100"),
+})
 ```
 
   </template>
@@ -1475,7 +1605,7 @@ To delete multiple documents by ID, you can use `filter_by=id: [id1, id2, id3]`.
 
 To delete all documents in a collection, you can use a filter that matches all documents in your collection.
 For eg, if you have an `int32` field called `popularity` in your documents, you can use `filter_by=popularity:>0` to delete all documents.
-Or if you have a `bool` field called `in_stock` in your documents, you can use `filter_by=in_stock:[true,false]` to delete all documents.  
+Or if you have a `bool` field called `in_stock` in your documents, you can use `filter_by=in_stock:[true,false]` to delete all documents.
 
 :::
 
@@ -1483,7 +1613,7 @@ Or if you have a `bool` field called `in_stock` in your documents, you can use `
 
 Export documents in a collection in JSONL format.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Swift','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Swift','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -1526,6 +1656,13 @@ await client.collection('companies').documents.exportJSONL();
 ExportDocumentsParameters exportDocumentsParameters = new ExportDocumentsParameters();
 exportDocumentsParameters.setIncludeFields("id,publication_year,authors");
 client.collections("companies").documents().export(exportDocumentsParameters);
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Collection("companies").Documents().Export(context.Background())
 ```
 
   </template>

From 118c8dc7af4ded60afe0dc012c948fdaec044e9d Mon Sep 17 00:00:00 2001
From: Hayden <hayden.hhoang@gmail.com>
Date: Fri, 18 Oct 2024 22:13:46 +0700
Subject: [PATCH 3/3] docs(go): curation API

---
 docs-site/content/27.1/api/curation.md | 101 ++++++++++++++++++++-----
 1 file changed, 80 insertions(+), 21 deletions(-)

diff --git a/docs-site/content/27.1/api/curation.md b/docs-site/content/27.1/api/curation.md
index 105a36b1..aa2f919c 100644
--- a/docs-site/content/27.1/api/curation.md
+++ b/docs-site/content/27.1/api/curation.md
@@ -19,16 +19,16 @@ When using [Synonyms](./synonyms.md) and Overrides together, Overrides are handl
 
 In the following example, we will:
 
-1. Use the `includes` condition to place the documents with ids `422` and `54` in the first and second positions 
+1. Use the `includes` condition to place the documents with ids `422` and `54` in the first and second positions
    respectively.
-2. Use the `excludes` condition to remove the document with id `287` from the results. 
-   
+2. Use the `excludes` condition to remove the document with id `287` from the results.
+
 Typesense allows you to use both `includes` and `excludes` or just one of them for curation.
 
-Note how we are applying these overrides to an `exact` match of the query `apple`. Instead, if we want to match all 
+Note how we are applying these overrides to an `exact` match of the query `apple`. Instead, if we want to match all
 queries containing the word `apple`, we will use the `contains` match instead.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -150,6 +150,27 @@ searchOverrideSchema.addIncludesItem(new SearchOverrideInclude().id("422").posit
 // Creates/updates an override called `customize-apple` in the `companies` collection
 SearchOverride searchOverride = client.collections("companies").overrides().upsert("customize-apple", searchOverrideSchema);
 
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+override := &api.SearchOverrideSchema{
+  Rule: api.SearchOverrideRule{
+    Query: "apple",
+    Match: "exact",
+  },
+  Includes: &[]api.SearchOverrideInclude{
+    {Id: "422", Position: 1},
+    {Id: "54", Position: 2},
+  },
+  Excludes: &[]api.SearchOverrideExclude{
+    {Id: "287"},
+  },
+}
+// Creates/updates an override called `customize-apple` in the `companies` collection
+client.Collection("companies").Overrides().Upsert(context.Background(), "customize-apple", override)
 ```
 
   </template>
@@ -228,7 +249,7 @@ You can add tags to override rules and then trigger curation by referring to the
     ]
 }
 ```
-Now, when we search the collection, we can pass one or more tags via the `override_tags` parameter to directly 
+Now, when we search the collection, we can pass one or more tags via the `override_tags` parameter to directly
 trigger the curations rules that match the tags:
 
 ```json
@@ -241,18 +262,18 @@ trigger the curations rules that match the tags:
 
 If `override1` is tagged with `tagA,tagB`, and `override2` is tagged with just `tagA` and `override3` is not tagged:
 
-1. If a search sets `override_tags` to `tagA`, we only consider overrides that contain `tagA` (`override1` and `override2`) 
+1. If a search sets `override_tags` to `tagA`, we only consider overrides that contain `tagA` (`override1` and `override2`)
    with the usual logic -- in alphabetic order of override name and then process both if stop rule processing is false.
-2. If a search sets `override_tags` to `tagA,tagB`, we evaluate any rules that contain both `tagA` and tagB first, 
-   then rules with either `tagA` or `tagB`, but not overrides that contain no tags. Within each group, we evaluate 
-   in alphabetic order of override name and process multiple rules if `stop_processing` is `false`. 
+2. If a search sets `override_tags` to `tagA,tagB`, we evaluate any rules that contain both `tagA` and tagB first,
+   then rules with either `tagA` or `tagB`, but not overrides that contain no tags. Within each group, we evaluate
+   in alphabetic order of override name and process multiple rules if `stop_processing` is `false`.
 3. If a search sets no `override_tags`, we only consider rules that have no tags associated with them.
 
 ### Dynamic filtering
 
 In the following example, we will apply a filter dynamically to a query that matches a rule.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -350,6 +371,23 @@ searchOverrideSchema.rule(new SearchOverrideRule().query("{brand} phone")
 // Creates/updates an override called `customize-apple` in the `companies` collection
 SearchOverride searchOverride = client.collections("companies").overrides().upsert("brand-filter", searchOverrideSchema);
 
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+override := &api.SearchOverrideSchema{
+  Rule: api.SearchOverrideRule{
+    Query: "{brand} phone",
+    Match: "contains",
+  },
+  FilterBy:            pointer.String("brand:={brand}"),
+  RemoveMatchedTokens: pointer.True(),
+}
+
+// Creates/updates an override called `brand-filter` in the `companies` collection
+client.Collection("companies").Overrides().Upsert(context.Background(), "brand-filter", override)
 ```
 
   </template>
@@ -371,22 +409,22 @@ curl "http://localhost:8108/collections/companies/overrides/brand-filter" -X PUT
   </template>
 </Tabs>
 
-With this override in effect, any query that contains a brand will automatically be filtered on the matching brand 
-directly. In addition, the brand will also be removed from the original query tokens, so that the search is made 
-only on the remaining tokens. 
+With this override in effect, any query that contains a brand will automatically be filtered on the matching brand
+directly. In addition, the brand will also be removed from the original query tokens, so that the search is made
+only on the remaining tokens.
 
-For example, if someone searches for `sony ericsson phone`, the query will be re-written as `phone` and a 
-`sony ericsson` brand filter will be directly applied. If you don't wish to remove matching tokens from the query, 
+For example, if someone searches for `sony ericsson phone`, the query will be re-written as `phone` and a
+`sony ericsson` brand filter will be directly applied. If you don't wish to remove matching tokens from the query,
 set `remove_matched_tokens` to `false`. By default, this parameter is set to `true`.
 
 :::tip Note
-Fields used in the query for dynamic filtering should have `facet: true` in their field definition in the schema. 
+Fields used in the query for dynamic filtering should have `facet: true` in their field definition in the schema.
 :::
 
 ### Curation and filtering
 
 `includes` is used to fix documents at certain positions in the results, but it's possible for these documents to
-be filtered out when using `filter_curated_hits: true`. 
+be filtered out when using `filter_curated_hits: true`.
 
 When this happens, Typesense "slides" any remaining documents added by `includes` up in the results.
 For example, say you have a collection of product records that look like this when sorted on a `ranking` field:
@@ -467,7 +505,7 @@ Listing all overrides associated with a given collection.
 
 NOTE: By default, ALL overrides are returned, but you can use the `offset` and `limit` parameters to paginate on the listing.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -508,6 +546,13 @@ await client.collection('companies').overrides.retrieve();
 
 ```java
 SearchOverridesResponse searchOverridesResponse = client.collections("companies").overrides().retrieve();
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Collection("companies").Overrides().Retrieve(context.Background())
 ```
 
   </template>
@@ -565,7 +610,7 @@ curl -H "X-TYPESENSE-API-KEY: ${TYPESENSE_API_KEY}" \
 ## Retrieve an override
 Fetch an individual override associated with a collection.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -606,6 +651,13 @@ await client.collection('companies').override('customize-apple').retrieve();
 
 ```java
 SearchOverride searchOverride = client.collections("companies").overrides("customize-apple").retrieve();
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Collection("companies").Override("customize-apple").Retrieve(context.Background())
 ```
 
   </template>
@@ -659,7 +711,7 @@ curl "http://localhost:8108/collections/companies/overrides/customize-apple" -X
 ## Delete an override
 Deleting an override associated with a collection.
 
-<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Shell']">
+<Tabs :tabs="['JavaScript','PHP','Python','Ruby','Dart','Java','Go','Shell']">
   <template v-slot:JavaScript>
 
 ```js
@@ -700,6 +752,13 @@ await client.collection('companies').override('customize-apple').delete();
 
 ```java
 SearchOverride searchOverride = client.collections("companies").overrides("customize-apple").delete();
+```
+
+  </template>
+  <template v-slot:Go>
+
+```go
+client.Collection("companies").Override("customize-apple").Delete(context.Background())
 ```
 
   </template>