Building AI Applications using frameworks with MariaDB Vector Store

Posted on 6月 17, 2025 by
spacer

Vector databases have become essential for building intelligent applications. Since MariaDB Community Server version 11.7 and most recently in the MariaDB Community Server 11.8 LTS release, MariaDB has embraced this trend by introducing native vector store capabilities. While you could work with vectors using pure SQL, dedicated frameworks have made this process incredibly simple, allowing you to focus on building your AI applications rather than dealing with complex vector operations.

The Power of Dedicated Frameworks

While MariaDB Foundation’s blog entry and this video show how to work with vectors using pure SQL, modern frameworks improve the development experience. These frameworks handle all the complexity of:

  • Vector operations and similarity calculations
  • Document chunking and processing
  • Embedding generation and management
  • Database connection handling
  • Query optimization

This means you can focus on building your AI applications without worrying about the underlying vector operations. Let’s see how these frameworks make it incredibly easy to work with MariaDB vector stores.

Processing PDF and Creating Embeddings

Thanks to dedicated frameworks, processing documents and creating embeddings is now a straightforward process. Here’s how simple it is in different languages:

Python Implementation

After installing dependencies:

pip install langchain-mariadb langchain_community pypdf pymysql langchain-text-splitters langchain-openai mariadb
export OPENAI_API_KEY=...

With LangChain, you can process documents and create embeddings in just a few lines of code:

from langchain_mariadb import MariaDBStore
from langchain_openai import OpenAIEmbeddings
from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter

# 1. Load and split the PDF - just two lines!
loader = PyPDFLoader("mariadb-documentation.pdf")
documents = loader.load()
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200
)
texts = text_splitter.split_documents(documents)

# 2. Initialize embeddings and vector store - one line each!
vector_store = MariaDBStore(
    embeddings=OpenAIEmbeddings(),
    embedding_length=1536,
    datasource="mysql+mariadbconnector://myuser:mypassword@localhost:3306/vectordb",
    collection_name="mariadb_docs"
)

# 3. Add documents - just one line!
vector_store.add_documents(texts)

Node.js Implementation

After installing dependencies:

npm install @langchain/community @langchain/core @langchain/openai @langchain/textsplitters mariadb pdf-parse
export OPENAI_API_KEY=...

LangChain.js makes it equally simple with a modern, async-first approach:

import { MariaDBStore } from "@langchain/community/vectorstores/mariadb";
import { OpenAIEmbeddings } from "@langchain/openai";
import { PDFLoader } from "@langchain/community/document_loaders/fs/pdf";
import { RecursiveCharacterTextSplitter } from "@langchain/textsplitters";
import mariadb from "mariadb";

async function createData() {
// 1. Load and split the PDF - just a few lines!
    const loader = new PDFLoader("C:/temp/mariadb_tutorial.pdf");
    const docs = await loader.load();
    const textSplitter = new RecursiveCharacterTextSplitter({
        chunkSize: 1000,
        chunkOverlap: 200
    });
    const splitDocs = await textSplitter.splitDocuments(docs);

    const vectorStore = await MariaDBStore.initialize(
        new OpenAIEmbeddings(),
        {
            pool: mariadb.createPool("mariadb://myuser:mypassword@localhost:3306/mydb"),
            distanceStrategy: 'COSINE',
        }
    );
    await vectorStore.addDocuments(splitDocs);
}
createData();

Java Implementation

Spring AI brings the power of vector stores to Java with familiar Spring patterns. Here’s an exampleapplication.yml configuration file:

spring:
  application:
    name: mariadb-test
  datasource:
    url: jdbc:mariadb://localhost/spring-ai
    username: myuser
    password: mypassword
  ai:
    vectorstore:
      mariadb:
        initialize-schema: true
        distance-type: COSINE
        dimensions: 1536
    openai:
      api-key: ${OPEN_AI_KEY}
@Service
public class DocumentProcessingService {
    @Autowired
    private VectorStore vectorStore;

    // Just one method to handle everything!
    public void processPDF(String pdfPath) {
        var reader = new PagePdfDocumentReader(pdfPath);
        var splitter = new TokenTextSplitter();
        List<Document> documents = splitter.apply(reader.get());
        vectorStore.add(documents);
    }
}

Performing Similarity Search

The frameworks make similarity search just as simple. Here’s how easy it is to query your vector store:

Python Search Example

from langchain_mariadb import MariaDBStore
from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from langchain import hub

llm = ChatOpenAI(temperature=0)
vector_store = MariaDBStore(
    embeddings=OpenAIEmbeddings(),
    embedding_length=1536,
    datasource="mysql+mariadbconnector://root:@localhost:3306/vectordb",
    collection_name="mariadb_docs"
)

prompt = hub.pull("rlm/rag-prompt")

rag_chain = (
        {"context": vector_store.as_retriever(), "question": RunnablePassthrough()}
        | prompt
        | llm
        | StrOutputParser()
)

response = rag_chain.invoke("How do I create a new table in MariaDB?")

print(f"Response: {response}")

Node.js Search Example

import {MariaDBStore} from "@langchain/community/vectorstores/mariadb";
import {OpenAIEmbeddings} from "@langchain/openai";
import mariadb from "mariadb";
import { ChatOpenAI } from "@langchain/openai";
import { pull } from "langchain/hub";

async function search() {
    const vectorStore = await MariaDBStore.initialize(
        new OpenAIEmbeddings(),
        {
            pool: mariadb.createPool("mariadb://myuser:mypassword@localhost:3306/mydb"),
            distanceStrategy: 'COSINE',
        }
    );
    let question = "How do I create a new table in MariaDB?";
    const llm = new ChatOpenAI({temperature: 0});

    const retrievedDocs = await vectorStore.similaritySearch(question);
    const docsContent = retrievedDocs.map((doc) => doc.pageContent).join("\n");
    const promptTemplate = await pull("rlm/rag-prompt");
    const messages = await promptTemplate.invoke({
        question: question,
        context: docsContent,
    });
    const answer = await llm.invoke(messages);
    console.log(answer.content);
}
search();

Java Search Example

@Service
public class SearchService {
    @Autowired
    private VectorStore vectorStore;

    @Autowired
    private ChatModel chatModel;

    public String search(String query) {
        var chatClient = ChatClient.builder(chatModel)
                .defaultAdvisors(new QuestionAnswerAdvisor(vectorStore))
                .build();
        return chatClient
                .prompt()
                .user(query)
                .call()
                .content();
    }
}

Conclusion

These frameworks really make MariaDB’s vector capabilities shine. They take care of all the complicated vector stuff behind the scenes, and here’s the best part: you don’t need to mess around with plugins, extra connectors to set up, no additional APIs to learn, no separate licensing headaches or documentation to wade through. By leveraging MariaDB’s native vector storage and search functionality, developers can seamlessly integrate AI frameworks without the overhead of managing a separate vector database, eliminating the need for specialized expertise while maintaining familiar SQL operations and your existing MariaDB setup.

Whether you’re working in Python, Node.js, or Java, these frameworks give you a straightforward way to work with vectors right alongside your regular data. You can spend your time actually building cool AI features instead of juggling multiple database systems or getting bogged down in vector operation details.

Resources