Comece com a integração do Spring AI

Crie um aplicativo Java Spring.

Navegue até o Initializr do Spring e defina seu projeto com as seguintes configurações:

• Projeto: Maven

• Idioma: Java

• Spring Boot: você pode usar a versão padrão selecionada.

• Metadados do projeto:

  • Java: 21

  • Você pode usar valores padrão para todos os outros campos.

No lado direito do Spring Initializr, clique em ADD DEPENDENCIES, procure e adicione as seguintes dependências:

• MongoDB Atlas Vector Database

• Spring Data MongoDB

Por fim, clique em GENERATE para baixar uma versão compactada do seu projeto Spring. Descompacte o arquivo e abra-o em seu IDE.

Adicionar dependências.

1. O Spring AI fornece configuração automática do Spring Boot para o Atlas Vector Search.

   Adicione as seguintes dependências à array dependencies no arquivo pom.xml do seu projeto. Essas dependências adicionam o Spring AI e a biblioteca de configuração automática ao seu aplicativo:

   <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. Em seguida, certifique-se de que seu arquivo pom.xml contenha uma entrada dependencyManagement para o Lista de materiais (BOM) do Spring AI.

   Importante

   Configure a constante do spring-ai.version utilizada para o BOM do Spring AI como 1.0.0-SNAPSHOT para implementar os recursos mais recentes do Spring AI em seu aplicativo.

   Para saber mais sobre o BOM da IA da Spring, consulte Gerenciamento de dependência seção da documentação da IA do Spring.

3. Por fim, adicione o repositório Spring AI Snapshot à entrada repositories no arquivo pom.xml :

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

   Para saber mais sobre esses repositórios, consulte a seção Adicionar repositórios de etapas e snapshots seção da documentação da IA do Spring.

   Depois de terminar de editar o arquivo pom.xml , recarregue seu projeto para garantir que suas dependências estejam instaladas.

Defina as propriedades do aplicativo.

Localize o arquivo src/main/resources/application.properties e substitua o conteúdo desse arquivo pelas seguintes propriedades. Substitua os placeholders por sua chave de API OpenAI e sua connection string do Atlas:

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>

Habilitar a inicialização do esquema.

Quando você configura o Atlas como o armazenamento de vetores em seu aplicativo, a IA do Spring pode inicializar o esquema de backend automaticamente. Esta inicialização inclui a criação de um índice do Atlas Vector Search na collection que contém suas incorporações vetoriais. Você pode habilitar a inicialização do esquema adicionando a seguinte configuração ao seu arquivo application.properties :

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

A especificação de initialize-schema=true faz com que a Spring AI crie programaticamente um índice do Atlas Vector Search em seu cluster. Por esse motivo, você deve conectar seu aplicativo a um cluster dedicado. Se você estiver executando um cluster de nível gratuito ou compartilhado, deverá criar separadamente o índice por meio da UI do Atlas, da Administration API do Atlas ou do Atlas CLI.

Para saber mais, consulte Criar um Índice do Atlas Vector Search.

Adicione declarações de importação.

Cole o seguinte código no arquivo Config.java para importar as classes necessárias:

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;

Propriedades do aplicativo de referência.

Cole o código abaixo no arquivo Config.java para fazer referência aos valores definidos no arquivo de propriedades do aplicativo:

@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...
}

Crie o EmbeddingModel bean Spring .

Em seguida, cole o seguinte código para gerar a instância OpenAiEmbeddingModel que utiliza a API OpenAI para criar incorporações vetoriais:

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

Crie o VectorStore bean Spring .

Por fim, cole o seguinte código para criar um bean que retorne uma instância VectorStore . A instância do VectorStore utiliza o MongoTemplate que corresponde ao seu sistema e o OpenAiEmbeddingModel criado na etapa anterior.

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