Vector Database and Spring IA
Tags: database, spring, ai, java
Published: 2024-02-11 21:11:24

A vector database is a specialized type of database optimized for handling vector data, which is fundamental in the field of Artificial Intelligence (AI), particularly in areas like machine learning, natural language processing, and image recognition.

## What is Vector Data?
Vector data refers to data represented in the form of vectors. In AI, a vector often is a numerical representation of complex data, like text, images, or sound. For instance, words in natural language processing can be converted into vectors using techniques like word embeddings (e.g., Word2Vec, GloVe). These vectors capture the semantic meaning of the words and allow AI models to process and understand language.

## How does a Vector Database Work?
Vector databases are designed to efficiently store and query vector data. Unlike traditional databases that perform queries based on exact matches or SQL queries, vector databases enable similarity searches. Here's how it works:

1. Storing Data: Data (like text or images) is transformed into vectors using AI models and then stored in the vector database.

2. Querying Data: When a query is made, it is also converted into a vector. The vector database then searches for vectors that are most similar to the query vector. This is known as a similarity or nearest neighbor search.

3. Similarity Measurement: The similarity between vectors is usually calculated using metrics like Euclidean distance, cosine similarity, or Manhattan distance. The choice of metric depends on the specific application and the nature of the data.

## Correlation with AI
The use of vector databases is highly correlated with AI for several reasons:

1. Enhanced AI Models: They enable AI models to access large amounts of relevant, context-rich data quickly. This is crucial for models that require contextual understanding, like chatbots or recommendation systems.

2. Retrieval Augmented Generation (RAG): This is a technique where, before generating a response, an AI model retrieves relevant information from a vector database. This helps in providing more accurate and context-aware outputs.

3. Efficiency in Handling High-Dimensional Data: AI often deals with high-dimensional data (like images or complex text). Vector databases are optimized for such data, ensuring efficient storage and retrieval, which is a challenge in traditional databases.

4. Real-Time Processing: In many AI applications, real-time response is crucial. Vector databases allow for quick retrieval of similar data, enabling real-time processing in AI applications.

In summary, vector databases play a crucial role in the AI ecosystem by enabling efficient storage and retrieval of vectorized data. They support AI models by providing a means to quickly access large volumes of contextually relevant data, which is essential for tasks requiring understanding and interpretation of complex data sets.




![Vector Database](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/f561u0suze5ndff1thwu.png)


## Spring IA 
The Spring AI project aims to streamline the development of applications that incorporate artificial intelligence functionality without unnecessary complexity. On this example we use features like: Embedding, Prompts, ETL and save all embedding on [PGvector](https://github.com/pgvector/pgvector)(Postgres Vector database)

### Embedding

As a software engineer, when you're working with the **Embeddings** API, think of the **EmbeddingClient** interface as a bridge connecting your application to the power of AI-based text analysis. Its main role is to transform textual information into a format that machines can understand - numerical vectors, known as embeddings. These vectors are instrumental in tasks like understanding the meaning of text (semantic analysis) and sorting text into categories (text classification).

From a software engineering perspective, the EmbeddingClient interface is built with two key objectives:

Portability: The design of this interface is like a universal adapter in the world of embedding models. It's crafted to fit seamlessly with various embedding techniques. This means, as a developer, you can easily switch from one embedding model to another without having to overhaul your code. This flexibility is in sync with the principles of modularity and interchangeability, much like how Spring framework operates.
Simplicity: With methods like embed(String text) and embed(Document document), EmbeddingClient takes the heavy lifting off your shoulders. It converts text to embeddings without requiring you to get tangled in the complexities of text processing and embedding algorithms. This is particularly beneficial for those who are new to the AI field, allowing them to leverage the power of embeddings in their applications without needing a deep dive into the technicalities.
In essence, as a software engineer, when you use EmbeddingClient, you're leveraging a tool that not only simplifies the integration of advanced AI capabilities into your applications but also ensures that your code remains agile and adaptable to various embedding models.


![Embedding Api](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/edu02y8kd7xlhmo8mo1r.jpg)

### Prompts

Working with Spring AI, you can  **prompts** can be thought of as the steering wheel for AI models, guiding them to produce specific outputs. The way these prompts are crafted plays a critical role in shaping the responses you get from the AI.

To draw a parallel with familiar concepts in software development, handling prompts in Spring AI is akin to how you manage the "View" component in the Spring MVC framework. In this scenario, creating a prompt is much like constructing an elaborate text template, complete with placeholders for dynamic elements. These placeholders are then substituted with actual data based on user input or other operations within your application, similar to how you might use placeholders in SQL queries.

As Spring AI continues to evolve, it aims to introduce more sophisticated methods for interacting with AI models. At its core, the current classes and functionalities in Spring AI could be compared to JDBC in terms of their fundamental role. For example, the ChatClient class in Spring AI can be likened to the essential JDBC library provided in the Java Development Kit (JDK).

Building on this foundation, just as JDBC is enhanced with utilities like JdbcTemplate and Spring Data Repositories, Spring AI is expected to offer analogous helper classes. These would streamline interactions with AI models, much like how JdbcTemplate simplifies JDBC operations.

Looking further ahead, Spring AI is poised to introduce even more advanced constructs. These might include elements like ChatEngines and Agents that are capable of considering the history of interactions with the AI model. This progression mirrors the way that software development has evolved from direct JDBC usage to more abstract and powerful tools like ORM frameworks.

In summary, as a software engineer working with Spring AI, you are at the forefront of integrating AI capabilities into applications, using familiar paradigms and patterns from traditional software development, but applied to the cutting-edge field of AI and machine learning.

### ETL pipeline

Extract, Transform, and Load (ETL) framework is crucial in managing data processes in the Retrieval Augmented Generation (RAG) scenario. Essentially, the ETL pipeline is the mechanism that streamlines the journey of data from its raw state to a more organized vector store. This process is vital for preparing the data in a way that makes it easily retrievable and usable by the AI model.

In the RAG use case, the core objective is to enhance the capabilities of generative AI models. This is achieved by integrating text-based data, which involves sourcing relevant information from a dataset to improve both the quality and the contextual relevance of the outputs generated by the model. The ETL framework plays a pivotal role in this process by ensuring that the data is not only accurately extracted and transformed but also efficiently loaded and stored for optimal retrieval by the AI system. This process enhances the AI's ability to produce more precise and contextually rich responses.

## Details of Project

We've developed a project that incorporates fundamental principles related to AI and the Spring library, focusing on concepts like Prompts, Embedding, ETL pipelines, and Vector Databases. Our aim is to provide a concise overview of each concept's functionality. The main goal is to integrate all these elements through a practical example and apply them to a routine solution.

The first step is to select a Vector Database for our use. Spring AI offers integration with various databases. In this instance, we've chosen to use **[pgvector](https://github.com/pgvector/pgvector)**

```
version: '3.7'
services:
  postgres:
    image: ankane/pgvector:v0.5.0
    restart: always
    environment:
      - POSTGRES_USER=postgres
      - POSTGRES_PASSWORD=admin
      - POSTGRES_DB=vector_db
      - PGPASSWORD=admin
    logging:
      options:
        max-size: 10m
        max-file: "3"
    ports:
      - '5433:5432'
    healthcheck:
      test: "pg_isready -U postgres -d vector_db"
      interval: 2s
      timeout: 20s
      retries: 10
```

for running pgvector you will run

```
docker compose up -d
```

In the project for use all Spring IA functionalities you will need add some dependencies: 

```
<spring-ai.version>0.8.0-SNAPSHOT</spring-ai.version>

<dependency>
  <groupId>org.springframework.ai</groupId>
  <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
  <version>${spring-ai.version}</version>
</dependency>

<dependency>
  <groupId>org.springframework.ai</groupId>
  <artifactId>spring-ai-pdf-document-reader</artifactId>
  <version>${spring-ai.version}</version>
</dependency>

<dependency>
  <groupId>org.springframework.ai</groupId>
  <artifactId>spring-ai-pgvector-store</artifactId>
  <version>${spring-ai.version}</version>
</dependency>
```

We use latest version of library 0.8.0-SNAPSHOT.

**Command to Run application**

```
mvn spring-boot:run -Dspring-boot.run.profiles=openai
```

We have divided our approach into two distinct parts: data handling and question processing.

**Data Handling**: This involves several key operations:

1. Loading: Importing data into our system.
Transforming: Modifying or processing the data to fit our needs.

2. Inserting: Adding new data entries into our database.
3. Retrieving: Accessing data from the database as needed.
4. Deleting: Removing data entries that are no longer required.

**Question Processing**: In this part, we utilize the data that has been loaded and processed. The aim here is to provide responses that are directly related to, and informed by, the data we have in our resources.

Regarding the data aspect, we have utilized a Technology Radar from ThoughtWorks as our primary data source."

About data, we used a Technology Radar from Thoughtwrorks

### Technology Radar

The Technology Radar is a snapshot of tools, techniques, platforms, languages and frameworks based on the practical experiences of Thoughtworkers around the world. Published twice a year, it provides insights on how the world builds software today. Use it to identify and evaluate what’s important to you.


![Technology Radar](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/i4zhkts53b8mwoghb6pw.png)


[Here the link from latest tech radar version](https://www.thoughtworks.com/content/dam/thoughtworks/documents/radar/2023/09/tr_technology_radar_vol_29_en.pdf)


With the content from the ThoughtWorks Technology Radar as our reference, we are now equipped to utilize our API to recommend the best tools or offer insights and opinions on various technologies.



![Response 1](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/268169bbmqfx83q5xfey.png)


![Response 2](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/bz9mm67ph64plwaq2gaq.png)


[Link of project](https://github.com/lucasnscr/SpringAI)