edits

Author: semihsalihoglu-uw

src/content/docs/client-apis/wasm.mdx

@@ -9,12 +9,11 @@ browsers.
 
 ## Benefits of WASM
 
-Kùzu-Wasm enables the following:
+Several benefits of Kùzu-Wasm are the following:
 
-- Fast, in-browser graph analysis without ever sending data to a server
-- Strong data privacy guarantees, as the data never leaves the browser
-- Real-time interactive dashboards
-- Lightweight, portable solutions that leverage graphs within web applications
+- Fast, in-browser graph analysis without ever sending data to a server.
+- Strong data privacy guarantees, as the data never leaves the browser.
+- Real-time interactive in-browser graph analytics and visualization.
 
 ## Installation
 
@@ -101,7 +100,7 @@ This script can be directly embedded in an HTML file, for example:
 ## Understanding the package
 
 In this package, three different variants of WebAssembly modules are provided:
-- **Default**: This is the default build of the WebAssembly module. It does not support multi-threading and uses Emscripten's default filesystem. This build has the smallest size and works in both Node.js and browser environments. It has the best compatibility and does not require cross-origin isolation. However, the performance maybe limited due to the lack of multithreading support. This build is located at the root level of the package.
+- **Default**: This is the default build of the WebAssembly module. It does not support multi-threading and uses Emscripten's default filesystem. This build has the smallest size and works in both Node.js and browser environments. It has the best compatibility and does not require cross-origin isolation. However, the performance may be limited due to the lack of multithreading support. This build is located at the root level of the package.
 - **Multi-threaded**: This build supports multi-threading and uses Emscripten's default filesystem. This build has a larger size compared to the default build and only requires [cross-origin isolation](https://web.dev/articles/cross-origin-isolation-guide) in the browser environment. This build is located in the `multithreaded` directory.
 - **Node.js**: This build is optimized for Node.js and uses Node.js's filesystem instead of Emscripten's default filesystem (`NODEFS` flag is enabled). This build also supports multi-threading. It is distributed as a CommonJS module rather than an ES module to maximize compatibility. This build is located in the `nodejs` directory. Note that this build only works in Node.js and does not work in the browser environment.
 

src/content/docs/extensions/full-text-search.md

@@ -4,12 +4,12 @@ title: "Full Text Search"
 
 ## Usage
 
-The `FTS` (full-text search) extension adds support for matching within the content of a string property
+The full-text search (`FTS`) extension adds support for matching within the content of a string property
 while returning the documents with a proximity score to the query. It is enabled by building an index
 on string properties in a table and allows searching through the strings via a keyword query.
 Currently, Kùzu supports only indexing on a node table's `STRING` properties.
 
-The FTS functionality is not available by default, so you would first need to install the `FTS`
+The FTS functionality is not available by default, so you first need to install the `FTS`
 extension by running the following commands:
 
 ```sql
@@ -31,46 +31,45 @@ CREATE (b:Book {abstract: 'A deep dive into the history of ancient civilizations
 CREATE (b:Book {abstract: 'A fantasy tale of dragons and magic.', author: 'Charlotte Harris', title: 'The Dragon\'s Call'});
 ```
 
-In the following sections, we will build a full-text search index on the book table, and demonstrate how to search for books relevant to a keyword query.
-
+In the following sections, we show how to build and query a full-text search index on the book table.
 ### Create FTS index
 
 Kùzu provides a function `CREATE_FTS_INDEX` to create the full-text search index on a table:
 
 ```cypher
 CALL CREATE_FTS_INDEX('TABLE_NAME', 'INDEX_NAME', ['PROP1', 'PROP2', 'PROP3'...], OPTIONAL_PARAM1 := 'OPTIONAL_VAL1')
 ```
-- `TABLE_NAME`: The name of the table to build FTS index.
-- `INDEX_NAME`: The name of the FTS index to create.
-- `PROPERTIES`: A list of properties in the table to build FTS index on. Full text search will only search the properties with FTS index built on.
+- `TABLE_NAME`: The name of the table to build the FTS index on.
+- `INDEX_NAME`: The name of the created FTS index.
+- `PROPERTIES`: The list of properties in the table to build the FTS index on. The strings in these
+  properties will be tokenized and indexed. The FTS index will only match keywords across 
+  these indexed properties. 
 
 The following optional parameters are supported:
 
 - `stemmer`: The text normalization technique to use. Should be one of: `arabic`, `basque`, `catalan`, `danish`, `dutch`, `english`, `finnish`, `french`, `german`, `greek`, `hindi`, `hungarian`, `indonesian`, `irish`, `italian`, `lithuanian`, `nepali`, `norwegian`, `porter`, `portuguese`, `romanian`, `russian`, `serbian`, `spanish`, `swedish`, `tamil`, `turkish`, or `none` if no stemming is to be used. Defaults to `english`,
 which uses a Snowball stemmer.
 
-The example below shows how to create an FTS index on the book table with the `abstract`, `author` and `title` properties using the `porter` stemmer.
+The example below shows how to create an FTS index on the book table with the `abstract`, `author`, and `title` properties using the `porter` stemmer.
 
 :::caution[Note]
-Kùzu uses special syntax for optional parameters. Note how the `:=` operator is used to assign a value
+Syntax of optional parameters: Kùzu uses special syntax for optional parameters. Note how the `:=` operator is used to assign a value
 to an optional parameter in the example below.
 :::
 
 ```cypher
 CALL CREATE_FTS_INDEX(
-    'Book',   // Table name
-    'book_index',   // Index name
-    ['abstract', 'author', 'title'],   // Properties to build FTS index on
-    stemmer := 'porter'   // Stemmer to use (optional)
+    'Book', // Table name
+    'book_index', // Index name
+    ['abstract', 'author', 'title'], // Properties to build FTS index on
+    stemmer := 'porter' // Stemmer to use (optional)
 )
 ```
-
-Depending on the size of the dataset, the index creation may take some time. Once the index creation is complete,
-the index will be ready to use for full-text search.
+Once the index is created, the index will be ready for querying as shown below.
 
 ### Query FTS index
 
-Kùzu provides a table function `QUERY_FTS_INDEX` to query the FTS index on a table using the [Okapi BM25](https://en.wikipedia.org/wiki/Okapi_BM25) scoring algorithm:
+Kùzu provides the `QUERY_FTS_INDEX` function to query the FTS index on a table using the [Okapi BM25](https://en.wikipedia.org/wiki/Okapi_BM25) scoring algorithm:
 
 ```cypher
 CALL QUERY_FTS_INDEX(
@@ -80,17 +79,22 @@ CALL QUERY_FTS_INDEX(
     OPTIONAL_PARAM1 := 'OPTIONAL_VAL1'...
 )
 ```
-- `TABLE_NAME`: The name of the table to query
-- `INDEX_NAME`: The name of the FTS index to query
-- `QUERY`: The query string
+- `TABLE_NAME`: The name of the table to query.
+- `INDEX_NAME`: The name of the FTS index to query. 
+- `QUERY`: The query string that contains the keywords to search.
 
+:::caution[Note]
+Uniqueness of index names: If you build multiple FTS indices on a table, they 
+must have different names. However, multiple FTS indices can have the same
+name as long as each one is built on a separate table.
+:::
 The following optional parameters are supported:
 
-1. `conjunctive`: Whether all keywords in the query should appear in order for a document to be retrieved, default to false.
-2. `K`: parameter controls the influence of term frequency saturation. It limits the effect of additional occurrences of a term within a document. Defaults to 1.2.
-3. `B`: parameter controls the degree of length normalization by adjusting the influence of document length. Defaults to 0.75.
+1. `conjunctive`: Whether all keywords in the query should appear in order for a document to be retrieved. Defaults to false.
+2. `K`: controls the influence of term frequency saturation. This limits the effect of additional occurrences of a term within a document. Defaults to 1.2.
+3. `B`: controls the degree of length normalization by adjusting the influence of document length. Defaults to 0.75.
 
-Detailed explanation of k and b values can be found [there](https://learn.microsoft.com/en-us/azure/search/index-ranking-similarity)
+Detailed explanation of k and b values can be found [here](https://learn.microsoft.com/en-us/azure/search/index-ranking-similarity).
 
 The below example shows how to query books related to the `quantum machine` and order the books by their scores:
 ```cypher
@@ -161,14 +165,14 @@ CALL DROP_FTS_INDEX('Book', 'book_index')
 
 ### Show FTS indexes
 
-There is no function specifically to show FTS indexes, but there is a general function [`SHOW_INDEXES`](/cypher/query-clauses/call) that
+There is no function to specifically show FTS indexes, but there is a general function [`SHOW_INDEXES`](/cypher/query-clauses/call) that
 can be used to show all the indexes available in the database.
 
 ```cypher
 CALL SHOW_INDEXES() RETURN *;
 ```
 This will return a list of all the indexes available in the database, while also listing the type of each
-index. Scan the table to find the FTS indexes that are currently available.
+index.
 
 ```
 ┌────────────┬─────────────┬────────────┬─────────────────────────┬──────────────────┬─────────────────────────────────────────────────────────────────────────────────────────────────────┐
@@ -182,21 +186,20 @@ index. Scan the table to find the FTS indexes that are currently available.
 ### Prepared statement
 
 [Prepared statements](/get-started/prepared-statements) allows you to execute a query with different parameter values without rebinding the same query.
-A typical use case where parameters are useful is when you want to find books with different contents.
-
-Example:
-Let's start with preparing a cypher statement which queries the `book_index`.
+You can parameterize your `CALL QUERY_FTS_INDEX` calls. For example,
+suppose you want to find books with different keywords. We give
+an example below using our C++ API but you can create prepared statements in other APIs as well.
+We first prepare a Cypher statement which queries the `book_index` with a parameter `q`.
 ```c++
 auto preparedStatement = conn->prepare("CALL QUERY_FTS_INDEX('Book', 'book_index', $q) RETURN node.ID, score;");
 ```
-Now, we can find books with different contents using the prepared statement without rebinding.
-
-#### Find books related to `machine learning`
+Now, we can find books with different keywords using the prepared statement and 
+specifying different values for `q`. For example, to query the index with keywords `machine learning`, we can do:
 ```c++
 auto result = conn->execute(prepared.get, std::make_pair(std::string("q"), std::string("machine learning")));
 ```
 
-#### Find books related to `dragons`
+Similarly, to query the index with the keyword `dragons`, we can do:
 ```c++
 auto result = conn->execute(prepared.get, std::make_pair(std::string("q"), std::string("dragons")));
 ```

src/content/docs/get-started/prepared-statements.mdx

@@ -5,7 +5,7 @@ title: "Run prepared Cypher statements"
 Just like we have [SQL injection](https://en.wikipedia.org/wiki/SQL_injection) in relational databases,
 we can also have Cypher injection in graph databases. This is when a user can manipulate the query
 to execute arbitrary code that can threaten the integrity of the data. As a best practice, it's
-generally to provide parameters to your Cypher queries instead of using string literals in your code.
+generally a good idea to provide parameters to your Cypher queries instead of using string literals in your code.
 
 This section shows to run *prepared* Cypher statements with parameters while working with a client
 API in Kùzu.
@@ -17,7 +17,7 @@ Instead of hardcoding the age value into a Cypher query, it would make more sens
 to the query, so that the same query can be reused for other values.
 
 Another situation where parameters are useful is when you want to loop through a list of records and
-write each record to the database. Because records may have differnt values for a given property, it's
+write each record to the database. Because records may have different values for a given property, it's
 a good idea to use parameters to provide the values dynamically.
 
 ## Syntax
@@ -65,6 +65,9 @@ conn.execute(
     """
 )
 ```
-
+:::caution[Note]
+You can also use provide parameters to `CALL QUERY_FTS_INDEX(...)` function calls.
+See the documentation on [FTS Index](/extensions/full-text-search#prepared-statement) for more details.
+:::