Spring Ai Vector Store

<dependency>
    <groupId>pro.redisson</groupId>
    <artifactId>redisson-spring-ai-store-starter-10</artifactId>
    <version>xVERSIONx</version>
</dependency>

compile 'pro.redisson:redisson-spring-ai-store-starter-10:xVERSIONx'

<dependency>
    <groupId>pro.redisson</groupId>
    <artifactId>redisson-spring-ai-store-10</artifactId>
    <version>xVERSIONx</version>
</dependency>

compile 'pro.redisson:redisson-spring-ai-store-10:xVERSIONx'

spring:
  ai:
    vectorstore:
      redisson:
        index-name: my-index
        prefix: doc:
        initialize-schema: true
        vector-algorithm: HNSW
        distance-metric: COSINE
        hnsw:
          m: 16
          ef-construction: 200
          ef-runtime: 10
        metadata-fields:
          - name: category
            type: TAG
          - name: year
            type: NUMERIC

@Autowired 
VectorStore vectorStore;

// ...

List<Document> documents = List.of(
    new Document("Spring AI rocks!! Spring AI rocks!!", Map.of("category", "framework", "year", 2024)),
    new Document("The World is Big and Salvation Lurks Around the Corner"),
    new Document("You walk forward facing the past and you turn back toward the future.", Map.of("category", "philosophy", "year", 2023)));

// Add the documents to Redis
vectorStore.add(documents);

// Retrieve documents similar to a query
List<Document> results = vectorStore.similaritySearch(
    SearchRequest.builder()
        .query("Spring")
        .topK(5)
        .build());

spring:
  ai:
    vectorstore:
      redisson:
        index-name: "my-index"
        prefix: "doc:"
        initialize-schema: true
        vector-algorithm: HNSW
        distance-metric: COSINE
        hnsw:
          m: 16
          ef-construction: 200
          ef-runtime: 10	  
        metadata-fields:
          - name: category
            type: TAG
          - name: description
            type: TEXT
          - name: year
            type: NUMERIC
          - name: price
            type: NUMERIC

vectorStore.similaritySearch(SearchRequest.builder()
        .query("The World")
        .topK(5)
        .similarityThreshold(0.7)
        .filterExpression("country in ['UK', 'NL'] && year >= 2020")
        .build());

FilterExpressionBuilder b = new FilterExpressionBuilder();

vectorStore.similaritySearch(SearchRequest.builder()
        .query("The World")
        .topK(5)
        .similarityThreshold(0.7)
        .filterExpression(b.and(
                b.in("country", "UK", "NL"),
                b.gte("year", 2020)).build())
        .build());

@Configuration
public class VectorStoreConfig {

    @Bean(destroyMethod = "shutdown")
    public RedissonClient redisson() {
        Config config = new Config();
        config.useSingleServer()
              .setAddress("redis://127.0.0.1:6379");
        return Redisson.create(config);
    }

    @Bean
    public VectorStore vectorStore(RedissonClient redissonClient, EmbeddingModel embeddingModel) {
        return RedissonVectorStore.builder(redissonClient, embeddingModel)
            .indexName("custom-index")
            .prefix("custom-prefix")
            .vectorAlgorithm(Algorithm.HNSW)
            .distanceMetric(DistanceMetric.COSINE)
            .hnswM(16)
            .hnswEfConstruction(200)
            .hnswEfRuntime(10)
            .metadataFields(
                MetadataField.tag("category"),
                MetadataField.numeric("year"),
                MetadataField.text("description"))
            .initializeSchema(true)
            .build();
    }

    @Bean
    public EmbeddingModel embeddingModel() {
        // Configure your embedding model (OpenAI, Ollama, etc.)
        return new OpenAiEmbeddingModel(new OpenAiApi(System.getenv("OPENAI_API_KEY")));
    }
}

@Service
public class RagService {

    private final ChatClient chatClient;
    private final VectorStore vectorStore;

    public RagService(ChatClient.Builder chatClientBuilder, VectorStore vectorStore) {
        this.chatClient = chatClientBuilder.build();
        this.vectorStore = vectorStore;
    }

    public String askQuestion(String question) {
        // Retrieve relevant documents
        List<Document> relevantDocs = vectorStore.similaritySearch(
            SearchRequest.builder()
                .query(question)
                .topK(3)
                .similarityThreshold(0.7)
                .build()
        );

        // Build context from retrieved documents
        String context = relevantDocs.stream()
            .map(Document::getContent)
            .collect(Collectors.joining("\n\n"));

        // Generate response with context
        return chatClient.prompt()
            .user(u -> u.text("""
                Based on the following context, answer the question.
                
                Context:
                {context}
                
                Question: {question}
                """)
                .param("context", context)
                .param("question", question))
            .call()
            .content();
    }
}

spring:
  ai:
    vectorstore:
      redisson:
        index-name: "semantic-search-index"
        prefix: "doc:"
        initialize-schema: true
        metadata-fields:
          - name: source
            type: TAG
          - name: category
            type: TAG

@Service
public class SemanticSearchService {

    private final VectorStore vectorStore;

    public SemanticSearchService(VectorStore vectorStore) {
        this.vectorStore = vectorStore;
    }

    // Index documents
    public void indexDocuments(List<String> texts, String source) {
        List<Document> documents = texts.stream()
            .map(text -> new Document(text, Map.of("source", source)))
            .toList();

        vectorStore.add(documents);
    }

    // Search by natural language query
    public List<Document> search(String query, int topK) {
        return vectorStore.similaritySearch(
            SearchRequest.builder()
                .query(query)
                .topK(topK)
                .similarityThreshold(0.7)
                .build());
    }

    // Search scoped to a specific source with metadata filtering
    public List<Document> searchBySource(String query, String source) {
        return vectorStore.similaritySearch(
            SearchRequest.builder()
                .query(query)
                .topK(5)
                .similarityThreshold(0.7)
                .filterExpression("source == '" + source + "'")
                .build());
    }
}

// Index documents from a known source
searchService.indexDocuments(List.of(
    "Spring Boot simplifies Java application development",
    "Docker containers enable consistent deployments",
    "Kubernetes orchestrates containerized workloads",
    "PostgreSQL is a powerful open-source relational database"
), "knowledge-base");

// Search across all indexed documents — returns results about containers and orchestration
List<Document> results = searchService.search("how do I deploy my app reliably", 5);

// Search scoped to a specific source only
List<Document> scoped = searchService.searchBySource("relational database options", "knowledge-base");

spring:
  ai:
    vectorstore:
      redisson:
        index-name: "recommendations-index"
        prefix: "article:"
        initialize-schema: true
        metadata-fields:
          - name: articleId
            type: TAG
          - name: title
            type: TEXT
          - name: category
            type: TAG

@Service
public class RecommendationService {

    private final VectorStore vectorStore;

    public RecommendationService(VectorStore vectorStore) {
        this.vectorStore = vectorStore;
    }

    // Store an article with metadata
    public void addArticle(String id, String title, String content, String category) {
        vectorStore.add(List.of(new Document(
            content,
            Map.of("articleId", id, "title", title, "category", category)
        )));
    }

    // Find articles similar to a given article's content
    public List<Map<String, Object>> findSimilarArticles(String articleContent, int topK) {
        return vectorStore.similaritySearch(
                SearchRequest.builder()
                    .query(articleContent)
                    .topK(topK + 1) // +1 to account for the article itself
                    .similarityThreshold(0.75)
                    .build())
            .stream()
            .map(doc -> Map.of(
                "id",       doc.getMetadata().get("articleId"),
                "title",    doc.getMetadata().get("title"),
                "category", doc.getMetadata().get("category"),
                "score",    doc.getScore()
            ))
            .toList();
    }

    // Recommend articles based on a user's reading history
    public List<Map<String, Object>> recommendFromHistory(List<String> readArticleContents) {
        // Combine recent reading history into a single semantic query
        String combinedContext = String.join(" ", readArticleContents);

        return vectorStore.similaritySearch(
                SearchRequest.builder()
                    .query(combinedContext)
                    .topK(10)
                    .similarityThreshold(0.65)
                    .build())
            .stream()
            .map(doc -> Map.of(
                "id",       doc.getMetadata().get("articleId"),
                "title",    doc.getMetadata().get("title"),
                "category", doc.getMetadata().get("category"),
                "score",    doc.getScore()
            ))
            .toList();
    }
}

// Index some articles
recommendationService.addArticle("1", "Intro to Spring AI",      "Spring AI intro content...",    "AI");
recommendationService.addArticle("2", "LangChain vs Spring AI",  "Comparison article content...", "AI");
recommendationService.addArticle("3", "Docker Best Practices",   "Container content...",          "DevOps");

// Get articles similar to article 1 — will surface article 2 as highly similar
List<Map<String, Object>> similar = recommendationService.findSimilarArticles("Spring AI intro content...", 3);

// Recommend based on a user who recently read articles 1 and 2
List<Map<String, Object>> recommended = recommendationService.recommendFromHistory(
    List.of("Spring AI intro content...", "Comparison article content..."));

spring:
  ai:
    vectorstore:
      redisson:
        index-name: "agent-memory-index"
        prefix: "memory:"
        initialize-schema: true
        metadata-fields:
          - name: sessionId
            type: TAG
          - name: type
            type: TAG
          - name: timestamp
            type: TEXT

@Service
public class AgentMemoryService {

    private final VectorStore vectorStore;
    private final ChatClient chatClient;

    public AgentMemoryService(VectorStore vectorStore, ChatClient.Builder chatClientBuilder) {
        this.vectorStore = vectorStore;
        this.chatClient = chatClientBuilder.build();
    }

    // Persist a memory (conversation turn, fact, or observation)
    public void remember(String sessionId, String memoryText, String type) {
        vectorStore.add(List.of(new Document(
            memoryText,
            Map.of(
                "sessionId", sessionId,
                "type",      type,          // "conversation", "fact", "preference"
                "timestamp", Instant.now().toString()
            )
        )));
    }

    // Recall memories relevant to the current input, scoped to a session
    public List<Document> recall(String sessionId, String currentInput, int topK) {
        return vectorStore.similaritySearch(
            SearchRequest.builder()
                .query(currentInput)
                .topK(topK)
                .similarityThreshold(0.6)
                .filterExpression("sessionId == '" + sessionId + "'")
                .build());
    }

    // Chat with memory-augmented context
    public String chat(String sessionId, String userMessage) {
        // 1. Recall relevant past memories for this session
        List<Document> memories = recall(sessionId, userMessage, 5);

        String memoryContext = memories.isEmpty()
            ? "No relevant memories."
            : memories.stream()
                .map(Document::getContent)
                .collect(Collectors.joining("\n- ", "- ", ""));

        // 2. Build a system prompt that injects the recalled context
        String systemPrompt = """
            You are a helpful assistant with memory of past interactions.

            Relevant context from memory:
            %s

            Use this context to personalize your response where appropriate.
            """.formatted(memoryContext);

        // 3. Call the LLM with the enriched prompt
        String response = chatClient.prompt()
            .system(systemPrompt)
            .user(userMessage)
            .call()
            .content();

        // 4. Persist this interaction for future recall
        remember(sessionId, "User asked: " + userMessage, "conversation");
        remember(sessionId, "Assistant responded: " + response, "conversation");

        return response;
    }
}

// Teach the agent facts about a user
memoryService.remember("user-42", "User prefers concise answers", "fact");
memoryService.remember("user-42", "User is a Java developer", "fact");
memoryService.remember("user-42", "User dislikes verbose responses", "preference");

// Start a conversation — relevant facts and past turns are recalled automatically
String reply1 = memoryService.chat("user-42", "What is Spring AI?");

// Follow-up turn — the agent remembers the previous exchange and user preferences
String reply2 = memoryService.chat("user-42", "How do I add a vector store to it?");

// Recall only facts stored for a user, filtered by type
List<Document> facts = memoryService.recall("user-42", "communication style", 5)
    .stream()
    .filter(doc -> "fact".equals(doc.getMetadata().get("type")))
    .toList();