SpringAI 通过 Ollama 本地部署 Deepseek 模型实现对话机器人

修改配置文件 application.yml，指定模型名称和本地 Ollama 地址：

spring:
  ai:
    ollama:
      chat:
        options:
          model: deepseek-r1:7b
      base-url: http://localhost:11434

运行应用后，即可看到模型输出的对话内容。

构建数据库与 RAG

增强检索 RAG

RAG（Retrieval-Augmented Generation）的核心在于 Embedding（嵌入）。我们将文本转换为数值向量，以便计算语义相似度。先拉取一个轻量级的 Embedding 模型：

ollama pull all-minilm

向量数据库

这里选用 pgvector，它是 PostgreSQL 的扩展，支持向量相似性搜索。相比 Redis，它更适合需要持久化和复杂查询的场景。

使用 Docker 启动 pgvector 容器：

docker run -d --name pgvector -p 5433:5432 -e POSTGRES_USER=postgres -e POSTGRES_PASSWORD=postgres pgvector/pgvector:pg16

*注：若网络受限，请确保配置好代理以确保镜像拉取成功。

SpringBoot 集成 pgvector

引入 Spring AI 的 pgvector 依赖：

<!-- 引入 pgvector-->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-pgvector-store-spring-boot-starter</artifactId>
</dependency>

配置文件中需指定索引类型、距离度量方式及数据库连接信息：

spring:
  ai:
    vectorstore:
      pgvector:
        index-type: HNSW
        distance-type: COSINE_DISTANCE
        dimensions: 384
        batching-strategy: TOKEN_COUNT
        max-document-batch-size: 1000
    ollama:
      chat:
        options:
          model: deepseek-r1:7b
        embedding:
          enabled: true
          model: all-minilm
      base-url: http://localhost:11434
    datasource:
      url: jdbc:postgresql://localhost:5433/springai
      username: postgres
      password: postgres

启动服务后，执行 SQL 脚本初始化表结构：

create extension if not exists vector;
create extension if not exists hstore;
create extension if not exists "uuid-ossp";

create TABLE if not exists vector_store(
    id uuid DEFAULT uuid_generate_v4() PRIMARY KEY,
    content text,
    metadata json,
    embedding vector(384)
);

create index on vector_store using HNSW(embedding vector_cosine_ops);

将资源文件中的文本数据导入向量库。创建一个 VectorAPI 控制器：

package com.yan.springai.vector;

import lombok.RequiredArgsConstructor;
import org.springframework.ai.document.Document;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;

@RestController
@RequiredArgsConstructor
public class VectorAPI {
    final VectorStore store;

    // 导入方法
    @GetMapping("/vec/write")
    public String write() throws IOException {
        StringBuffer text = new StringBuffer();
        ClassLoader classLoader = getClass().getClassLoader();
        InputStream inputStream = classLoader.getResourceAsStream("ncode.txt");

        try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream))) {
            String line;
            while ((line = reader.readLine()) != null) {
                text.append(line);
            }
        }

        // 按照句号将文本切分并写入向量库
        store.write(Arrays.stream(text.toString().split("。"))
                .map(Document::new)
                .toList());
        return "success";
    }
}

访问 /vec/write 接口触发导入。此时模型回答仍基于通用知识，为了利用私有数据，我们需要修改 Init 配置，加入 QuestionAnswerAdvisor。

// ... 省略部分代码
import org.springframework.ai.chat.client.advisor.QuestionAnswerAdvisor;
// ...
final VectorStore vectorStore;

@Bean
public ChatClient chatClient(ChatMemory chatMemory) {
    return ChatClient.builder(model2)
            .defaultSystem("假如你是特朗普，接下来的对话你必须以特朗普的语气来进行？")
            .defaultAdvisors(
                    new MessageChatMemoryAdvisor(chatMemory), 
                    new QuestionAnswerAdvisor(vectorStore)
            )
            .build();
}
// ...

再次测试，模型现在能够根据向量库中的内容进行回答，RAG 流程跑通。

PDF 文档处理

SpringAI 提供了 PDF 文档读取器，可以将 PDF 内容解析并入库。

引入依赖：

<!-- 将 pdf 引入向量数据库-->
<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-pdf-document-reader</artifactId>
</dependency>

编写代码读取 baogao.pdf 并写入向量库：

package com.yan.springai.Pdf;

import lombok.RequiredArgsConstructor;
import org.springframework.ai.reader.ExtractedTextFormatter;
import org.springframework.ai.reader.pdf.PagePdfDocumentReader;
import org.springframework.ai.reader.pdf.config.PdfDocumentReaderConfig;
import org.springframework.ai.vectorstore.VectorStore;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequiredArgsConstructor
public class Pdf {
    final VectorStore store;

    @GetMapping("/pdf/read")
    public String getDocsFromPdf() {
        PagePdfDocumentReader pdfReader = new PagePdfDocumentReader(
                "classpath:/baogao.pdf",
                PdfDocumentReaderConfig.builder()
                        .withPageTopMargin(0)
                        .withPageExtractedTextFormatter(
                                ExtractedTextFormatter.builder()
                                        .withNumberOfTopTextLinesToDelete(0)
                                        .build()
                        )
                        .withPagesPerDocument(1)
                        .build()
        );
        store.write(pdfReader.read());
        return "success";
    }
}

Function Call 调用自定义函数

虽然 Deepseek 对 Function Call 的支持有限，但 SpringAI 架构本身支持此功能。我们可以注册自定义逻辑供模型调用。

定义业务逻辑类：

package com.yan.springai.func;

import java.util.function.Function;

public class OaService implements Function<OaService.Rquest, OaService.Response> {
    public Response apply(Rquest rquest) {
        // 实现逻辑，这里是请假逻辑
        System.err.printf("%s is token off%n", rquest.who);
        return new Response(10);
    }

    public record Rquest(String who) { }
    public record Response(int days) { }
}

注册到 Spring 容器中：

package com.yan.springai.func;

import org.springframework.ai.model.function.FunctionCallback;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FunctionRegistry {
    @Bean
    public FunctionCallback askForLeaveCallBack() {
        return FunctionCallback.builder()
                .function("askForLeave", new OaService())
                .description("当有人请假时，返回请假天数")
                .build();
    }
}

Controller 中调用：

package com.yan.springai.func;

import lombok.RequiredArgsConstructor;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequiredArgsConstructor
public class FuncAPI {
    final ChatClient chatClient;

    @GetMapping("/ai/func")
    public String funcCall(@RequestParam(value = "message") String message) {
        return chatClient.prompt(message)
                .functions("askForLeave")
                .call().content();
    }
}

多模态能力

多模态模型（Multimodal LLMs）能理解图片、音频等。Deepseek 原生不支持，可切换至 LLaVA 模型体验。

拉取 LLaVA 模型：

ollama run llava

在资源目录放入一张图片 cat.png，编写 Controller 进行识别：

package com.yan.springai.model;

import lombok.RequiredArgsConstructor;
import org.springframework.ai.chat.messages.Message;
import org.springframework.ai.chat.messages.UserMessage;
import org.springframework.ai.chat.prompt.ChatOptions;
import org.springframework.ai.chat.prompt.Prompt;
import org.springframework.ai.model.Media;
import org.springframework.ai.ollama.OllamaChatModel;
import org.springframework.ai.ollama.api.OllamaModel;
import org.springframework.core.io.ClassPathResource;
import org.springframework.util.MimeTypeUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@RequiredArgsConstructor
public class ImageAPI {
    final OllamaChatModel model;

    @GetMapping("/ai/chatWithPic")
    public String chatWithPic() {
        ClassPathResource imageData = new ClassPathResource("/cat.png");
        Message userMessage = new UserMessage(
                "请用中文描述一下这张图片是什么东西？",
                List.of(new Media(MimeTypeUtils.IMAGE_PNG, imageData))
        );
        return model.call(new Prompt(
                List.of(userMessage),
                ChatOptions.builder()
                        .model(OllamaModel.LLAVA.getName())
                        .build()
        )).getResult().getOutput().getText();
    }
}

至此，基于 SpringAI + Ollama 的本地化 AI 应用核心功能已基本覆盖。