Get Started with the Spring AI Integration

Create a Spring Java application.

Navigate to the Spring Initializr and configure your project with the following settings:

• Project: Maven

• Language: Java

• Spring Boot: You can use the default version that is selected.

• Project Metadata:

  • Java: 21

  • You can use default values for all other fields.

On the right side of the Spring Initializr, click ADD DEPENDENCIES, then search for and add the following dependencies:

• MongoDB Atlas Vector Database

• Spring Data MongoDB

Finally, click GENERATE to download a zipped version of your Spring project. Unzip the file and open it in your IDE.

Add dependencies.

1. Spring AI provides Spring Boot auto-configuration for Atlas Vector Search.

   Add the following dependencies to the dependencies array in your project's pom.xml file. These dependencies add Spring AI and the auto-configuration library to your application:

   <dependency>
       <groupId>org.springframework.ai</groupId>
       <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
   </dependency>
   <dependency>
       <groupId>org.springframework.ai</groupId>
       <artifactId>spring-ai-spring-boot-autoconfigure</artifactId>
   </dependency>
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
   </dependency>

2. Next, ensure that your pom.xml file contains a dependencyManagement entry for the Spring AI Bill of Materials (BOM).

   Important

   Set the spring-ai.version constant used for the Spring AI BOM to 1.0.0-SNAPSHOT to implement the most recent Spring AI features into your application.

   To learn more about the Spring AI BOM, see the Dependency Management section of the Spring AI documentation.

3. Finally, add the Spring AI Snapshot repository into the repositories entry in the pom.xml file:

   <repository>
     <id>spring-snapshots</id>
     <name>Spring Snapshots</name>
     <url>https://repo.spring.io/snapshot</url>
     <releases>
       <enabled>false</enabled>
     </releases>
   </repository>

   To learn more about these repositories, see the Add Milestone and Snapshot Repositories section of the Spring AI documentation.

   After you finish editing the pom.xml file, reload your project to make sure your dependencies are installed.

Define application properties.

Locate the src/main/resources/application.properties file and replace the contents of that file with the following properties. Replace the placeholders with your OpenAI API key and your Atlas connection string:

spring.application.name=springai-mongodb
spring.ai.openai.api-key=<OpenAI API Key>
spring.ai.openai.embedding.options.model=text-embedding-ada-002
spring.data.mongodb.uri=<connection string>
spring.data.mongodb.database=springai_test
spring.ai.vectorstore.mongodb.indexName=vector_index
spring.ai.vectorstore.mongodb.collection-name=vector_store

mongodb+srv://<db_username>:<db_password>@<clusterName>.<hostname>.mongodb.net/?<settings>

Enable schema initialization.

When you configure Atlas as the vector store in your application, Spring AI can initialize the backend schema automatically. This initialization includes creating an Atlas Vector Search index on the collection that contains your vector embeddings. You can enable schema initialization by adding the following setting to your application.properties file:

spring.ai.vectorstore.mongodb.initialize-schema=true

Specifying initialize-schema=true causes Spring AI to programmatically create an Atlas Vector Search index on your cluster. Because of this, you must connect your application to a dedicated cluster. If you're running a free or shared tier cluster, you must separately create the index through the Atlas UI, Atlas Administration API, or Atlas CLI.

To learn more, see Create an Atlas Vector Search Index.

Add import statements.

Paste the following code into the Config.java file to import the necessary classes:

import org.springframework.ai.embedding.EmbeddingModel;
import org.springframework.ai.openai.OpenAiEmbeddingModel;
import org.springframework.ai.openai.api.OpenAiApi;
import org.springframework.ai.vectorstore.MongoDBAtlasVectorStore;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringBootConfiguration;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.core.MongoTemplate;

Reference application properties.

Paste the following code into the Config.java file to reference the values that you set in your application properties file:

@Configuration
@SpringBootConfiguration
@EnableAutoConfiguration
public class Config {
    @Value("${spring.ai.openai.api-key}")
    private String openAiKey;
    @Value("${spring.data.mongodb.database}")
    private String databaseName;
    @Value("${spring.ai.vectorstore.mongodb.collection-name:vector_store}")
    private String collectionName;
    @Value("${spring.ai.vectorstore.mongodb.indexName:vector_index}")
    private String indexName;
    @Value("${spring.data.mongodb.uri}")
    private String mongoUri;
    @Value("${spring.ai.vectorstore.mongodb.initialize-schema}")
    private Boolean initSchema;
    // Add beans here...
}

Create the EmbeddingModel Spring bean.

Next, paste the following code to generate the OpenAiEmbeddingModel instance that uses the OpenAI API to create vector embeddings:

@Bean
public EmbeddingModel embeddingModel() {
    return new OpenAiEmbeddingModel(new OpenAiApi(openAiKey));
}

Create the VectorStore Spring bean.

Finally, paste the following code to create bean that returns a VectorStore instance. The VectorStore instance uses the MongoTemplate that corresponds to your deployment and the OpenAiEmbeddingModel created in the preceding step.

@Bean
public VectorStore mongodbVectorStore(MongoTemplate mongoTemplate, EmbeddingModel embeddingModel) {
    return new MongoDBAtlasVectorStore(mongoTemplate, embeddingModel,
            MongoDBAtlasVectorStore.MongoDBVectorStoreConfig.builder().build(), initSchema);
}