Convert to ascii doc

Signed-off-by: Tran Ngoc Nhan <ngocnhan.tran1996@gmail.com>

Author: ngocnhan-tran1996

spring-ai-docs/src/main/antora/modules/ROOT/pages/api/vectordbs.adoc

@@ -28,7 +28,8 @@ Spring AI offers an abstracted API for interacting with vector databases through
 
 Spring AI provides a read-only interface called `VectorStoreRetriever` that exposes only the document retrieval functionality:
 
-```java
+[source,java]
+----
 @FunctionalInterface
 public interface VectorStoreRetriever {
 
@@ -38,15 +39,16 @@ public interface VectorStoreRetriever {
         return this.similaritySearch(SearchRequest.builder().query(query).build());
     }
 }
-```
+----
 
 This functional interface is designed for use cases where you only need to retrieve documents from a vector store without performing any mutation operations. It follows the principle of least privilege by exposing only the necessary functionality for document retrieval.
 
 === VectorStore Interface
 
 The `VectorStore` interface extends `VectorStoreRetriever` and adds mutation capabilities:
 
-```java
+[source,java]
+----
 public interface VectorStore extends DocumentWriter, VectorStoreRetriever {
 
     default String getName() {
@@ -65,13 +67,14 @@ public interface VectorStore extends DocumentWriter, VectorStoreRetriever {
 		return Optional.empty();
 	}
 }
-```
+----
 
 The `VectorStore` interface combines both read and write operations, allowing you to add, delete, and search for documents in a vector database.
 
 === SearchRequest Builder
 
-```java
+[source,java]
+----
 public class SearchRequest {
 
 	public static final double SIMILARITY_THRESHOLD_ACCEPT_ALL = 0.0;
@@ -144,7 +147,7 @@ public class SearchRequest {
 	public Filter.Expression getFilterExpression() {...}
 }
 
-```
+----
 
 To insert data into the vector database, encapsulate it within a `Document` object.
 The `Document` class encapsulates content from a data source, such as a PDF or Word document, and includes text represented as a string.
@@ -417,7 +420,8 @@ The general usage of loading data into a vector store is something you would do
 Given a `String` reference to a source file that represents a JSON file with data we want to load into the vector database, we use Spring AI's `JsonReader` to load specific fields in the JSON, which splits them up into small pieces and then passes those small pieces to the vector store implementation.
 The `VectorStore` implementation computes the embeddings and stores the JSON and the embedding in the vector database:
 
-```java
+[source,java]
+----
 @Autowired
 VectorStore vectorStore;
 
@@ -427,15 +431,16 @@ void load(String sourceFile) {
     List<Document> documents = jsonReader.get();
     this.vectorStore.add(documents);
 }
-```
+----
 
 === Reading from a Vector Store
 
 Later, when a user question is passed into the AI model, a similarity search is done to retrieve similar documents, which are then "stuffed" into the prompt as context for the user's question.
 
 For read-only operations, you can use either the `VectorStore` interface or the more focused `VectorStoreRetriever` interface:
 
-```java
+[source,java]
+----
 @Autowired
 VectorStoreRetriever retriever; // Could also use VectorStore here
 
@@ -450,15 +455,16 @@ SearchRequest request = SearchRequest.builder()
     .build();
 
 List<Document> filteredDocuments = retriever.similaritySearch(request);
-```
+----
 
 Additional options can be passed into the `similaritySearch` method to define how many documents to retrieve and a threshold of the similarity search.
 
 === Separation of Read and Write Operations
 
 Using the separate interfaces allows you to clearly define which components need write access and which only need read access:
 
-```java
+[source,java]
+----
 // Write operations in a service that needs full access
 @Service
 class DocumentIndexer {
@@ -486,7 +492,7 @@ class DocumentRetriever {
         return retriever.similaritySearch(query);
     }
 }
-```
+----
 
 This separation of concerns helps create more maintainable and secure applications by limiting access to mutation operations only to components that truly need them.
 
@@ -505,7 +511,8 @@ The `VectorStoreRetriever` interface provides a read-only view of a vector store
 
 You can use `VectorStoreRetriever` directly when you only need to perform similarity searches:
 
-```java
+[source,java]
+----
 @Service
 public class DocumentRetrievalService {
 
@@ -529,15 +536,16 @@ public class DocumentRetrievalService {
         return retriever.similaritySearch(request);
     }
 }
-```
+----
 
 In this example, the service only depends on the `VectorStoreRetriever` interface, making it clear that it only performs retrieval operations and doesn't modify the vector store.
 
 === Integration with RAG Applications
 
 The `VectorStoreRetriever` interface is particularly useful in RAG applications, where you need to retrieve relevant documents to provide context for an AI model:
 
-```java
+[source,java]
+----
 @Service
 public class RagService {
 
@@ -563,7 +571,7 @@ public class RagService {
         return chatModel.generate(prompt);
     }
 }
-```
+----
 
 This pattern allows for a clean separation between the retrieval component and the generation component in RAG applications.