Spring 集成 DeepSeek 的 3大方法（史上最全）-阿里云开发者社区

本文原始地址

本文的原始地址 , 传送门

@[toc]

尼恩：LLM大模型学习圣经PDF的起源

在40岁老架构师尼恩的读者交流群(50+)中，经常性的指导小伙伴们改造简历。

经过尼恩的改造之后，很多小伙伴拿到了一线互联网企业如得物、阿里、滴滴、极兔、有赞、希音、百度、网易、美团的面试机会，拿到了大厂机会。

然而，其中一个成功案例，是一个9年经验网易的小伙伴，当时拿到了一个年薪近80W的大模型架构offer，逆涨50%，那是在去年2023年的 5月。

惊天大逆袭：8年小伙20天时间提75W年薪offer，逆涨50%，秘诀在这

不到1年，小伙伴也在团队站稳了脚跟，成为了名副其实的大模型应用架构师。接下来，尼恩架构团队，通过梳理一个《LLM大模型学习圣经》帮助更多的人做LLM架构，拿到年薪100W, 这个内容体系包括下面的内容：

《Python学习圣经：从0到1精通Python，打好AI基础》
《LLM大模型学习圣经：从0到1吃透Transformer技术底座》
《LangChain学习圣经：从0到1精通LLM大模型应用开发的基础框架》
《LLM大模型学习圣经：从0到1精通RAG架构，基于LLM+RAG构建生产级企业知识库》
《SpringCloud + Python 混合微服务架构，打造AI分布式业务应用的技术底层》
《LLM大模型学习圣经：从0到1吃透大模型的顶级架构》
《LLM 智能体学习圣经：从0到1吃透 LLM 智能体的架构与实操》
《LLM 智能体学习圣经：从0到1吃透 LLM 智能体的中台架构与实操》

以上学习圣经的配套视频， 2025年 5月份之前发布。

Spring 整合 deepseek 模型的三种方法

本文为 LLM大模型学习圣经PDF 系列文章中的一篇。

45岁老架构尼恩，由浅入深，给大家介绍一下 Spring如何整合当前最为火热的 deepseek 模型，

分为三种方式：

方法一：自定义 Client 集成DeepSeek
方法二：利用 spring-ai-openai 集成DeepSeek
方法三：利用Ollama 实现本地化部署 DeepSeek， Spring AI 的 spring-ai-ollama 模块访问 DeepSeek

DeepSeek是什么？

成立于2023年7月17日，由杭州知名量化资管巨头幻方量化创立，即深度求索，幻方量化为DeepSeek的技术研发提供了强大的硬件支持。

https://www.deepseek.com/

DeepSeek-V3 在推理速度上相较历史模型有大幅提升。在目前大模型主流榜单中，DeepSeek-V3 在开源模型中位列榜首，与世界上最先进的闭源模型不分伯仲。

先看DeepSeek发展历程

第一阶段：创立与核心技术突破（2023年）

2023年初，DeepSeek由多位来自中国顶尖高校和科技企业的AI专家联合创立。

创始团队认为，AGI的实现需要“更高效的模型架构”与“更低成本的训练方法”。

成立仅3个月后，团队即发布首个开源模型DeepSeek-R1，该模型在自然语言理解任务中以百亿参数量达到千亿级模型的性能，首次验证了“轻量化+高精度”技术路线的可行性。

这一突破迅速吸引投资机构关注，公司完成数亿元天使轮融资。

第二阶段：开源生态与行业落地（2024年）

2024年成为DeepSeek的生态扩张年。

公司推出DeepSeek-1.3B模型，首次在代码生成、多轮对话等复杂任务中超越同等规模的国际开源模型（如Meta的LLaMA），GitHub星标数突破3万。

同时，DeepSeek发布自研的分布式训练框架DeepSpeed-Lite，将大模型训练效率提升40%，并开源全套工具链。

这一阶段，DeepSeek与清华大学、上海人工智能实验室等机构建立联合实验室，推动学术与产业协同创新。

第三阶段：多模态与全球化布局（2025年至今）

2025年，DeepSeek发布全球首个千亿参数级多模态模型DeepSeek-Vision，支持文本、图像、视频的跨模态推理，在医疗影像分析、工业质检等领域实现商业化落地。

同年，公司与微软Azure达成战略合作，推出企业级AI平台DeepSeek Enterprise，服务金融、制造、教育等行业的500余家客户。

2026年，DeepSeek启动“全球开发者计划”，在硅谷、新加坡设立研发中心，模型下载量突破1000万次，成为GitHub最活跃的AI开源项目之一。

再来看DeepSeek 产品

DeepSeek 的产品很多，大家听说过的，或者常见的以下两种模型：

deepseek-chat（V3）：适用于聊天机器人、智能客服、内容生成等，能够理解和生成日常对话内容。
deepseek-reasoner（R1）：专为复杂推理任务设计，适合解决需要深度逻辑分析和推理的问题。

但是 DeepSeek 的模型还是很多的，尼恩给大家盘一下：

DeepSeek 语言模型类

DeepSeek LLM：

DeepSeek 发布的首个大模型，包含 670 亿参数，在 2 万亿 token 的中英文数据集上训练。开源了 DeepSeek LLM 7B/67B Base 和 DeepSeek LLM 7B/67B Chat。其中，DeepSeek LLM 67B Base 在推理、编码、数学和中文理解等方面超越了 Llama2 70B Base；DeepSeek LLM 67B Chat 在编码和数学方面表现出色，在匈牙利国家高中考试中取得 65 分，中文表现超越 GPT-3.5。

DeepSeek Coder：

由一系列代码语言模型组成，在 2 万亿 token 上训练，数据集含 87% 代码和 13% 中英文自然语言，模型尺寸从 1B 到 33B 版本不等。

通过在项目级代码语料库预训练，采用 16K 窗口大小和额外填空任务，支持项目级代码补全和填充，在多种编程语言和基准测试中达到开源代码模型先进性能。

DeepSeek 数学- 语言模型类

DeepSeekMath：

以 DeepSeek-Coder-v1.5 7B 为基础，在从 Common Crawl 中提取的数学相关 token 以及自然语言和代码数据上预训练，训练规模达 5000 亿 token。

DeepSeekMath 7B 在竞赛级 MATH 基准测试中取得 51.7% 的成绩，接近 Gemini-Ultra 和 GPT-4 的性能水平。

DeepSeek 视觉 - 语言模型类

DeepSeek-VL：

开源的视觉 - 语言（VL）模型，采用混合视觉编码器，能在固定 token 预算内高效处理高分辨率图像（1024x1024），保持较低计算开销。

DeepSeek-VL 系列（包括 1.3B 和 7B 模型）在相同模型尺寸下，在视觉 - 语言基准测试中性能先进或有竞争力。

DeepSeek-VL2：

先进的大型混合专家（MoE）视觉 - 语言模型系列，

有 DeepSeek-VL2-Tiny、DeepSeek-VL2-Small 和 DeepSeek-VL2 三个变体，分别具有 10 亿、28 亿和 45 亿激活参数。

在视觉问答、光学字符识别、文档 / 表格 / 图表理解以及视觉定位等多种任务中能力卓越，在相似或更少激活参数下性能具有竞争力或达最先进水平。

DeepSeek 其他模型

DeepSeek-V2：

拥有 2360 亿参数，每个 token 有 210 亿个活跃参数。

DeepSeek-V2 中文综合能力在众多开源模型中最强，超过 GPT-4，与 GPT-4-Turbo、文心 4.0 等闭源模型在评测中处于同一梯队；

DeepSeek-V2 英文综合能力与 LLaMA3-70B 处于同一梯队，超过最强 MoE 开源模型 Mixtral8x22B。

训练参数量达 8.1 万亿个 token，训练效率高。

DeepSeek-V3：

首个版本于 2024 年 12 月 26 日上线并开源，有 6710 亿参数，在 14.8 万亿 token 的数据集上训练，性能出色，在基准测试中超过 Llama 3.1 和 Qwen 2.5，与 GPT-4、Claude 3.5 Sonnet 相当。

DeepSeek-R1：

2025 年 1 月 20 日正式发布，在数学、代码、自然语言推理等任务上性能比肩 OpenAI o1 正式版。

1 月 24 日，在 Arena 上基准测试升至全类别大模型第三，在风格控制类模型分类中与 OpenAI o1 并列第一。

DeepSeek 和其他主流开源模型的对比

DeepSeek 和Llama 3.1、Qwen 2.5、GPT-4、Claude 几大模型的对比如下：

主流开源模型的架构对比

DeepSeek：

以 DeepSeek-V3 为例，采用混合专家（MoE）架构，总参数量达到 6710 亿，但每个输入仅激活约 5.5% 的参数（370 亿），还引入了多头潜在注意力（MLA）机制和无辅助损失的负载均衡策略。

Qwen 2.5：

是典型的 Dense 模型，所有参数都用于每个任务，拥有 72B 的参数。

Llama 3.1：

同样是 Dense 模型，参数规模达到 405B。

Claude：

Claude的架构独特，使其在处理复杂问题、生成结构化响应以及严格遵循输入提示方面有出色表现。

GPT-4：

采用基于 Transformer 的架构，复杂程度和参数规模较前代有显著提升，可能极为庞大，还引入了多模态处理能力。

性能表现的对比

语言理解：

在 MMLU 测试中，

DeepSeek-V3 达到 88.5% 的准确率，在 MMLU-Redux 测试中提升至 89.1%；

Claude-3.5 也有较高水准；

GPT-4o 具有强大多语言能力；

Llama 3.1 凭借 405B 参数有较强的自然语言理解能力；

Qwen 2.5 在处理复杂任务时有一定优势。

推理能力：

在 DROP 测试中，DeepSeek-V3 以 91.6% 的 3-shot F1 得分领先；

Claude-3.5 在 IF-Eval 测试中以 86.5% 的成绩领先，在复杂问答和严格按指令执行场景中优势明显；

GPT-4o 整体推理能力也很强；

Llama 3.1 和 Qwen 2.5 在推理方面也有一定表现，但相对上述模型稍弱。

代码生成：

Qwen 2.5 在 HumanEval-Mul 测试中准确率达 77.3%，在 Aider-Edit 测试中代码编辑和调试准确率达 84.2%，表现最佳；
DeepSeek-V3 在 Codeforces 竞赛编程测试中以 51.6% 的百分位数得分突出；
Llama 3.1、GPT-4 和 Claude 也有一定代码生成能力，但不如 Qwen 2.5 和 DeepSeek-V3 有特点。

数学能力：

在 AIME 2024、MATH-500 和 CNMO 2024 等测试中，DeepSeek-V3 表现优异；

其他模型相比之下稍逊一筹。

训练成本的对比

DeepSeek：以 DeepSeek-V3 为例，训练仅耗费 558 万美元，成本大幅降低至 Llama-3.1 的 1/11。
Llama 3.1：Meta 训练投入 5 亿美元。
GPT-42：训练成本高昂，使得许多团队望而却步。

应用场景的对比

DeepSeek：

采用无限制商用协议的开源策略，在医疗、教育等领域都有广泛应用，开发者可基于此开发各种工具和平台。

Qwen 2.5：

可用于多种自然语言处理场景，在阿里的一些产品和服务中发挥作用，如具备多模态功能，可帮助用户进行可视化开发等。

Llama 3.1：

可用于自然语言处理的众多任务，如文本生成、问答系统等，很多研究机构和企业基于其进行二次开发。

Claude：

在英语问答领域应用广泛，是许多英语 QA 应用的首选模型。

GPT-4：

应用场景极为广泛，涵盖教育、医疗、零售、娱乐等多个领域，由于多模态功能，可处理多种类型的任务。

混合专家（MoE）架构和 Transformer 的架构的区别

不同 LLM 大模型，在架构上有很大的不同。

GPT-4 采用基于 Transformer 的架构, DeepSeek-V3 采用了混合专家（MoE）架构

接下来，尼恩带看看混合专家（MoE）架构和 Transformer 的架构的区别。

混合专家（MoE）架构和 Transformer 架构，两大机构都是在深度学习领域中用于处理序列数据的重要架构，它们在设计理念、结构组成、计算效率和应用场景等方面存在明显区别：

结构组成的区别

Transformer 架构结构组成：

主要由编码器（Encoder）和解码器（Decoder）两部分组成（在不同应用中可以只使用编码器或解码器）。编码器和解码器都由多个相同的层堆叠而成，每层包含多头自注意力机制（Multi - Head Self - Attention）和前馈神经网络（Feed - Forward Network）。多头自注意力机制可以从不同的表示子空间捕捉输入序列的依赖关系，前馈神经网络则对注意力机制的输出进行非线性变换。

混合专家（MoE）架构结构组成：

在基本的神经网络结构基础上，引入了门控网络（Gating Network）和多个专家网络（Expert Networks）。门控网络根据输入数据决定将输入分配给哪些专家网络进行处理，专家网络则负责对分配到的数据进行具体的计算。

设计理念的区别

Transformer 架构设计理念：

Transformer 架构基于注意力机制的设计理念，旨在解决传统循环神经网络（RNN）在处理长序列时存在的梯度消失、难以并行计算等问题。它通过自注意力机制（Self - Attention）让模型在处理每个位置的输入时，能够关注到序列中其他位置的信息，从而捕捉序列中的长距离依赖关系。

混合专家（MoE）架构设计理念：

MoE 架构的核心设计理念是通过引入多个 “专家” 网络来处理不同类型的数据模式。每个专家网络可以专门学习数据中的特定模式或特征，根据输入动态地将不同部分分配给不同的专家进行处理，从而提高模型的表达能力和计算效率。

计算效率的区别

Transformer 架构：

所有的输入都要经过相同的网络结构进行处理，在处理大规模数据时，可能会导致计算资源的浪费，因为对于某些简单的输入，模型中复杂的网络结构可能并不需要全部参与计算。

混合专家（MoE）架构：

通过动态地将输入分配给不同的专家网络，可以减少不必要的计算。

只有被门控网络选中的专家网络才会参与计算，从而在一定程度上提高了计算效率，尤其是在处理大规模数据和复杂任务时。

Spring 整合 deepseek 模型的三种方法

介绍完了基础理论，解下来正式开始实操。

本文为 LLM大模型学习圣经PDF 的部分， 45岁老架构尼恩由浅入深，给大家介绍一下 Spring如何整合当前最为火热的 deepseek 模型，分为三种方式：

方法一：自定义 Client 集成DeepSeek
方法二：利用 spring-ai-openai 集成DeepSeek
方法三：利用Ollama 实现本地化部署 DeepSeek， Spring AI 的 spring-ai-ollama 模块访问 DeepSeek

方法一：自定义 Client 集成DeepSeek

DeepSeek 的 API 接口和 OpenAI 是兼容的。

我们可以自定义 http client，按照 OpenAI 的rest 接口格式，去访问 DeepSeek。

自定义 Client 集成DeepSeek ，可以通过以下步骤实现。

步骤 1：准备工作

(1) 获取 DeepSeek API 密钥：

访问 DeepSeek 的开发者平台，注册并获取 API 密钥。

(2) 确认 DeepSeek 的 OpenAI 兼容 API 地址：

DeepSeek 提供了与 OpenAI 兼容的 API 端点（例如 https://api.deepseek.com/v1），确保你已获取正确的 API 地址。

(3) Spring Boot 项目：

确保你已经有一个 Spring Boot 项目，或者创建一个新的 Spring Boot 项目。

步骤 2：添加依赖

在 pom.xml 中添加以下依赖：

Spring Boot Web（用于构建 REST API）
Apache HttpClient（用于发送 HTTP 请求）
Jackson（用于 JSON 序列化和反序列化）

<dependencies>
    <!-- Spring Boot Web -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- Apache HttpClient -->
    <dependency>
        <groupId>org.apache.httpcomponents</groupId>
        <artifactId>httpclient</artifactId>
        <version>4.5.13</version>
    </dependency>

    <!-- Jackson for JSON -->
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
    </dependency>
</dependencies>

步骤 3：配置 DeepSeek API

配置参数：在 application.yml 文件里，把 DeepSeek 的 API 端点和密钥写进去：

在 application.properties 或 application.yml 中配置 DeepSeek 的 API 密钥和端点：

// DeepSeek API 配置
deepseek.api.key=your-deepseek-api-key
deepseek.api.url=https://api.deepseek.com/v1

步骤 4：自定义 DeepSeek Client 客户端

创建一个 Spring 组件，用于封装与 DeepSeek API 的交互逻辑。

import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.io.IOException;

@Component
public class DeepSeekClient {

    @Value("${deepseek.api.key}")
    private String apiKey;

    @Value("${deepseek.api.url}")
    private String apiUrl;

    public String callDeepSeek(String prompt) throws IOException {
        String endpoint = apiUrl + "/completions"; // OpenAI 兼容的 completions 接口

        // 构建请求体
        String requestBody = String.format("{\"model\": \"deepseek-model\", \"prompt\": \"%s\", \"max_tokens\": 100}", prompt);

        // 创建 HTTP 请求
        HttpPost httpPost = new HttpPost(endpoint);
        httpPost.setHeader("Content-Type", "application/json");
        httpPost.setHeader("Authorization", "Bearer " + apiKey);
        httpPost.setEntity(new StringEntity(requestBody));

        // 发送请求并获取响应
        try (CloseableHttpClient httpClient = HttpClients.createDefault();
             CloseableHttpResponse response = httpClient.execute(httpPost)) {
            HttpEntity entity = response.getEntity();
            return EntityUtils.toString(entity);
        }
    }
}

步骤 5：创建 REST 控制器

代码实现：写个简单的控制器，通过 ChatClient 就能调用 DeepSeek 模型啦：

创建一个 REST 控制器，用于接收用户输入并调用 DeepSeek API。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api")
public class DeepSeekController {

    @Autowired
    private DeepSeekClient deepSeekClient;

    @PostMapping("/ask")
    public String askDeepSeek(@RequestParam String prompt) {
        try {
            return deepSeekClient.callDeepSeek(prompt);
        } catch (IOException e) {
            e.printStackTrace();
            return "Error calling DeepSeek API";
        }
    }
}

步骤 6：运行和测试

(1) 启动 Spring Boot 应用。

(2) 使用 Postman 或 curl 测试 /api/ask 接口：

请求方法：POST

URL：http://localhost:8080/api/ask?prompt=你的问题

示例：http://localhost:8080/api/ask?prompt=What is the capital of France?

(3) 检查返回的 JSON 响应，确认 DeepSeek 的生成结果。

示例响应

DeepSeek 的响应通常是一个 JSON 对象，类似于 OpenAI 的格式：

{
  "id": "cmpl-12345",
  "object": "text_completion",
  "created": 1677654321,
  "model": "deepseek-model",
  "choices": [
    {
      "text": "The capital of France is Paris.",
      "index": 0,
      "logprobs": null,
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 5,
    "completion_tokens": 6,
    "total_tokens": 11
  }
}

方法二：利用 spring-ai-openai 集成DeepSeek

DeepSeek 的 API 接口和 OpenAI 是兼容的。

Spring AI 的 spring-ai-openai 模块默认是为 OpenAI 设计的，但由于 DeepSeek 提供了与 OpenAI 兼容的 API，因此可以通过配置调整来实现对 DeepSeek 的调用。

这就意味着，咱们可以通过 Spring AI 的 spring-ai-openai 模块，轻轻松松把 DeepSeek 集成进来。具体怎么做呢？

利用 spring-ai-openai 集成DeepSeek ，可以通过以下步骤实现。

步骤 1：添加依赖

在 pom.xml 中添加 Spring AI 的 spring-ai-openai 模块依赖：

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-openai</artifactId>
    <version>0.8.0</version> <!-- 使用最新版本 -->
</dependency>

步骤 2：配置 DeepSeek API

在 application.properties 或 application.yml 中配置 DeepSeek 的 API 密钥和端点。

// DeepSeek API 配置
spring.ai.openai.api-key=your-deepseek-api-key
spring.ai.openai.base-url=https://api.deepseek.com/v1

spring.ai.openai.api-key：替换为你的 DeepSeek API 密钥。
spring.ai.openai.base-url：替换为 DeepSeek 的 OpenAI 兼容 API 地址。

步骤 3：创建 Spring AI 客户端

Spring AI 的 spring-ai-openai 模块会自动配置一个 OpenAiClient，你可以直接注入并使用它。

import org.springframework.ai.client.AiClient;
import org.springframework.ai.client.OpenAiClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class DeepSeekService {

    private final AiClient aiClient;

    @Autowired
    public DeepSeekService(AiClient aiClient) {
        this.aiClient = aiClient;
    }

    public String callDeepSeek(String prompt) {
        // 调用 DeepSeek 的 OpenAI 兼容 API
        return aiClient.generate(prompt);
    }
}

步骤 4：创建 REST 控制器

创建一个 REST 控制器，用于接收用户输入并调用 DeepSeek 服务。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api")
public class DeepSeekController {

    @Autowired
    private DeepSeekService deepSeekService;

    @PostMapping("/ask")
    public String askDeepSeek(@RequestParam String prompt) {
        return deepSeekService.callDeepSeek(prompt);
    }
}

步骤 5：运行和测试

(1) 启动 Spring Boot 应用。
(2) 使用 Postman 或 curl 测试 /api/ask 接口：

请求方法：POST

URL：http://localhost:8080/api/ask?prompt=你的问题

示例：http://localhost:8080/api/ask?prompt=What is the capital of France?
(3) 检查返回的响应，确认 DeepSeek 的生成结果。

示例响应

DeepSeek 的响应通常是一个字符串，类似于 OpenAI 的生成结果：

"The capital of France is Paris."

高级配置

如果你需要更高级的配置（如调整模型、温度、最大 token 数等），可以通过 OpenAiClient 的配置来实现。

调整生成参数

在调用 aiClient.generate() 时，可以传入一个 GenerateRequest 对象来指定生成参数：

import org.springframework.ai.client.GenerateRequest;
import org.springframework.ai.client.GenerateResponse;

public String callDeepSeek(String prompt) {
    GenerateRequest request = new GenerateRequest.Builder()
            .withPrompt(prompt)
            .withModel("deepseek-model") // 指定模型
            .withMaxTokens(100) // 最大 token 数
            .withTemperature(0.7) // 温度参数
            .build();

    GenerateResponse response = aiClient.generate(request);
    return response.getText();
}

用大白话介绍一下温度、最大 token 数

针对AI小白：什么是温度（Temperature）？

温度是控制模型生成文本的“创造力”或“随机性”的一个参数。你可以把它想象成调节模型的“脑洞大小”。

温度低（比如 0.1）：

模型会变得非常保守，倾向于选择最确定、最安全的答案。

适合需要准确性和一致性的任务，比如回答事实性问题。

例子：问“1+1等于几？”，模型会回答“2”，不会瞎编。
温度高（比如 1.0 或更高）：

模型会变得更有创造力，可能会给出一些意想不到的回答。

适合需要创意或多样性的任务，比如写故事、生成诗歌。

例子：问“写一首关于秋天的诗”，模型可能会生成一些充满想象力的句子。
温度适中（比如 0.7）：

模型会在保守和创意之间找到一个平衡点。

适合大多数任务，既能保证一定的准确性，又能有一些变化。

总结：

温度低 → 模型像“学霸”，回答严谨但可能无聊。
温度高 → 模型像“艺术家”，回答有趣但可能不靠谱。
温度适中 → 模型像“聪明人”，回答既靠谱又有趣。

针对AI小白：最大 token 数（Max Tokens）

token 是模型处理文本的基本单位，可以理解为一个词或一部分词。

比如：

英文单词“hello”是一个 token。
中文“你好”可能是两个 token（每个字一个 token）。
长单词或复杂字符可能会被拆成多个 token。

最大 token 数就是限制模型生成的文本长度。可以把它想象成给模型一个“字数限制”。

设置较小的最大 token 数（比如 50）：

模型生成的文本会非常短，可能只回答问题的核心部分。

例子：问“介绍一下太阳系”，模型可能只回答“太阳系包括太阳和八大行星”。
设置较大的最大 token 数（比如 500）：

模型生成的文本会更长，可能会包含更多细节。

例子：问“介绍一下太阳系”，模型可能会详细描述每颗行星的特点。
不设置最大 token 数：

模型可能会一直生成文本，直到达到它的内部限制（通常是几千个 token）。

这可能会导致生成的文本过长，甚至跑题。

总结：

最大 token 数小 → 模型像“话少的人”，回答简短。
最大 token 数大 → 模型像“话多的人”，回答详细。
不设置最大 token 数 → 模型像“话痨”，可能会一直说个不停。

方法三：用Ollama 实现本地化部署 DeepSeek， Spring AI 的 `spring-ai-ollama` 模块访问 DeepSeek

方法三使用 Ollama 实现本地化部署 DeepSeek，并通过 Spring AI 的 spring-ai-ollama 模块访问。

什么是 Ollama？

Ollama 是一个用于本地化部署和管理大型语言模型（LLM）的工具。

它支持多种开源模型（如 LLaMA、Alpaca 等），并提供了简单的 API 接口，方便开发者调用。

步骤 1：安装 Ollama

(1) 下载 Ollama：

访问 Ollama 官方 GitHub 或相关文档，下载适合你操作系统的版本。

(2) 安装 Ollama：

按照官方文档的安装步骤完成安装。

(3) 下载 DeepSeek 模型：

如果 DeepSeek 提供了与 Ollama 兼容的模型文件（如 .bin 或 .gguf 格式），将其下载到本地。

DeepSeek 的模型文件，可以从尼恩的网盘下载，具体可以通过本文后面的操作，找尼恩：

使用 Ollama 加载 DeepSeek 的模型文件，：

   ollama load /path/to/deepseek-model

(4) 启动 Ollama 服务：

启动 Ollama 服务，默认会监听 http://localhost:11434。

步骤 2：添加 Spring AI Ollama 依赖

spring-ai-ollama 是与 Spring AI 和 Ollama 相关的一个组件或集成模块：

Spring AI 是 Spring 框架家族中用于在 Spring 应用里集成人工智能服务的工具，它简化了与各类大语言模型（LLM）等 AI 服务的集成过程。
Ollama 是一个可以在本地运行大语言模型的工具，它提供了简单的命令行界面，方便用户在本地部署和使用不同的语言模型，无需依赖云服务。
spring-ai-ollama 则是将 Spring AI 和 Ollama 进行集成的桥梁，让开发者能够在 Spring 应用程序中方便地使用 Ollama 本地运行的语言模型。

在 pom.xml 中添加 Spring AI 的 spring-ai-ollama 模块依赖：

<dependency>
    <groupId>org.springframework.ai</groupId>
    <artifactId>spring-ai-ollama</artifactId>
    <version>0.8.0</version>  
</dependency>

Spring AI Ollama 功能特点

本地模型集成：借助 spring-ai-ollama，开发者可以在 Spring 应用中直接使用 Ollama 本地运行的大语言模型，避免了对外部云服务的依赖，提高了数据的安全性和隐私性，同时也能减少网络延迟。
简化开发流程：继承了 Spring AI 的特性，提供了统一的编程模型和接口，使得开发者可以像使用其他 Spring AI 支持的模型一样使用 Ollama 模型，降低了开发难度和复杂度。
配置灵活：支持多种配置方式，开发者可以根据自己的需求配置 Ollama 模型的相关参数，如模型名称、温度、最大生成长度等。

步骤 3：配置 Ollama

在 application.properties 或 application.yml 中配置 Ollama 的地址和模型名称。

// Ollama 配置
spring.ai.ollama.base-url=http://localhost:11434
spring.ai.ollama.model=deepseek-model

spring.ai.ollama.base-url：Ollama 服务的地址（默认是 http://localhost:11434）。
spring.ai.ollama.model：加载的 DeepSeek 模型名称。

步骤 4：创建 Spring AI 客户端

Spring AI 的 spring-ai-ollama 模块会自动配置一个 OllamaClient， OllamaClient 是 AiClient 类型的实现类对象。

可以直接注入OllamaClient ，类型是AiClient 并使用它。

import org.springframework.ai.client.AiClient;
import org.springframework.ai.client.OllamaClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class DeepSeekService {

    private final AiClient aiClient;

    @Autowired
    public DeepSeekService(AiClient aiClient) {
        this.aiClient = aiClient;
    }

    public String callDeepSeek(String prompt) {
        // 调用 Ollama 的 DeepSeek 模型
        return aiClient.generate(prompt);
    }
}

步骤 5：创建 REST 控制器

创建一个 REST 控制器，用于接收用户输入并调用 DeepSeek 服务。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api")
public class DeepSeekController {

    @Autowired
    private DeepSeekService deepSeekService;

    @PostMapping("/ask")
    public String askDeepSeek(@RequestParam String prompt) {
        return deepSeekService.callDeepSeek(prompt);
    }
}

步骤 6：运行和测试

(1) 启动 Spring Boot 应用。
(2) 使用 Postman 或 curl 测试 /api/ask 接口：

请求方法：POST
URL：http://localhost:8080/api/ask?prompt=你的问题
示例：http://localhost:8080/api/ask?prompt=What is the capital of France?

(3) 检查返回的响应，确认 DeepSeek 的生成结果。

示例响应

"The capital of France is Paris."

通过 `OllamaClient` 调整生成参数

如果你需要更高级的配置（如调整温度、最大 token 数等），可以通过 OllamaClient 的配置来实现。

在调用 aiClient.generate() 时，可以传入一个 GenerateRequest 对象来指定生成参数：

import org.springframework.ai.client.GenerateRequest;
import org.springframework.ai.client.GenerateResponse;

public String callDeepSeek(String prompt) {
    GenerateRequest request = new GenerateRequest.Builder()
            .withPrompt(prompt)
            .withModel("deepseek-model") // 指定模型
            .withMaxTokens(100) // 最大 token 数
            .withTemperature(0.7) // 温度参数
            .build();

    GenerateResponse response = aiClient.generate(request);
    return response.getText();
}

高级编程：通过chat API 接口实现多轮对话

如果需要支持多轮对话，可以使用 chat API 接口：

import org.springframework.ai.client.ChatClient;
import org.springframework.ai.client.ChatResponse;
import org.springframework.ai.client.Message;
import org.springframework.ai.client.MessageBuilder;

public String chatWithDeepSeek(String userMessage) {
    Message message = new MessageBuilder()
            .withRole("user")
            .withContent(userMessage)
            .build();

    ChatResponse response = aiClient.chat(message);
    return response.getReply();
}

ChatClient.chat(message) 是 Spring AI 中用于与大型语言模型（LLM）进行交互的核心方法之一，特别适合用于构建多轮对话系统。它允许开发者发送消息（Message 对象）并接收模型的回复（ChatResponse 对象），支持上下文感知和多轮对话。

1. ChatClient.chat(message) 的核心功能

多轮对话：支持基于上下文的对话，模型可以根据之前的对话历史生成连贯的回复。
角色管理：支持区分用户消息和模型回复（如 user 和 assistant 角色）。
上下文感知：模型可以根据之前的对话内容生成更准确的回复。
灵活的消息格式：支持单条消息或消息列表作为输入。

2. 多轮对话相关的核心类和方法

Message 类

Message 是表示对话中单条消息的类，包含以下属性：

角色（Role）：消息的发送者，通常是 user（用户）或 assistant（模型）。
内容（Content）：消息的文本内容。

import org.springframework.ai.client.Message;
import org.springframework.ai.client.MessageBuilder;

// 创建用户消息
Message userMessage = new MessageBuilder()
        .withRole("user") // 角色：用户
        .withContent("What is the capital of France?") // 内容
        .build();

ChatResponse 类

ChatResponse 是模型返回的回复对象，包含以下属性：

回复消息（ReplyMessage）：模型的回复内容，是一个 Message 对象。
其他元数据：如生成时间、token 使用情况等。

import org.springframework.ai.client.ChatResponse;

// 获取模型的回复
ChatResponse response = aiClient.chat(userMessage);
Message modelReply = response.getReplyMessage();
String replyContent = modelReply.getContent();

ChatClient 接口

ChatClient 是 Spring AI 提供的接口，定义了与 LLM 交互的核心方法：

chat(Message message)：发送单条消息并获取模型的回复。
chat(List messages)：发送多条消息（对话历史）并获取模型的回复。

3. chat AIP的使用步骤

步骤 1：创建消息对象

在调用 ChatClient.chat(message) 之前，需要创建一个 Message 对象。

import org.springframework.ai.client.Message;
import org.springframework.ai.client.MessageBuilder;

// 创建用户消息
Message userMessage = new MessageBuilder()
        .withRole("user") // 角色：用户
        .withContent("What is the capital of France?") // 内容
        .build();

步骤 2：调用 ChatClient.chat(message)

将 Message 对象传递给 ChatClient.chat(message)，获取模型的回复。

import org.springframework.ai.client.ChatClient;
import org.springframework.ai.client.ChatResponse;

public String chatWithModel(Message userMessage) {
    // 调用 chat 方法
    ChatResponse response = aiClient.chat(userMessage);
    // 获取模型的回复
    return response.getReplyMessage().getContent();
}

步骤 3：处理回复

ChatResponse 包含模型的回复内容。你可以通过 getReplyMessage() 方法获取回复的 Message 对象，并通过 getContent() 方法获取回复文本。

String modelReply = response.getReplyMessage().getContent();
System.out.println("Model Reply: " + modelReply);

4. 多轮对话示例

在多轮对话中，需要维护对话历史，并将历史消息传递给模型，以便模型能够理解上下文。

import org.springframework.ai.client.ChatClient;
import org.springframework.ai.client.ChatResponse;
import org.springframework.ai.client.Message;
import org.springframework.ai.client.MessageBuilder;

import java.util.ArrayList;
import java.util.List;

public class ChatService {

    private final ChatClient aiClient;
    private List<Message> chatHistory = new ArrayList<>();

    public ChatService(ChatClient aiClient) {
        this.aiClient = aiClient;
    }

    public String chat(String strMessage) {
        // 创建用户消息
        Message userMsg = new MessageBuilder()
                .withRole("user")
                .withContent(strMessage)
                .build();

        // 将用户消息添加到对话历史
        chatHistory.add(userMsg);

        // 调用 chat 方法，传入整个对话历史
        ChatResponse response = aiClient.chat(chatHistory);

        // 获取模型的回复
        Message modelReply = response.getReplyMessage();

        // 将模型的回复添加到  对话历史
        chatHistory.add(modelReply);

        // 返回模型的回复内容
        return modelReply.getContent();
    }
}

使用示例

ChatService chatService = new ChatService(aiClient);

// 第一轮对话
String reply1 = chatService.chat("What is the capital of France?");
System.out.println("Model Reply 1: " + reply1);

// 第二轮对话
String reply2 = chatService.chat("Tell me more about it.");
System.out.println("Model Reply 2: " + reply2);

通过 ChatClient.chat(message)，可以轻松构建基于 Spring AI 的多轮对话系统，并与本地或远程的 LLM 服务（如 Ollama 或 DeepSeek）进行交互。

Spring AI 到底好在哪？

Spring AI 是专门为了让集成 AI 模型变得更简单而设计的框架。

灵感来自 Python 里的 LangChain 和 LlamaIndex。

它的目标很明确，就是要让开发者在集成 AI 模型的时候，不用费那么大劲，代码还更好维护，用起来更灵活。

1 统一接口，轻松调用

Spring AI 有一套统一的 API，不管是 OpenAI、Hugging Face、DeepSeek 还是 Gemini 这些主流 AI 模型，它都能支持。

咱们开发者只要学会 Spring AI 的 API，调用不同模型就跟玩一样，不用再去研究每个模型复杂的底层代码。

2 自动配置，告别繁琐

以前配置 API 密钥、模型参数这些东西，可麻烦了。

现在 Spring AI 用配置文件就能自动管理这些关键信息，咱们简单设置一下就能搞定初始化，再也不用手动一步一步弄，省事儿多了。

3 灵活切换，适应多变需求

要是哪天想换个 AI 模型，在 Spring AI 里简直太简单了。

改改配置，业务代码都不用动，就能轻松实现不同模型的切换，不管啥样的应用场景，都能轻松应对。

Spring AI、LangChain 、 LlamaIndex 三大框架对标

简单的AI应用，使用 Spring AI 就够了。

但是复杂的AI应用，还是需要 LangChain 或者 LlamaIndex 等其他 python 系列的工具包。

Spring AI、LangChain 和 LlamaIndex 是三个不同的技术框架或工具，分别用于不同的应用场景。

以下是它们的简要介绍和对比：

1. Spring AI

Spring AI 是基于 Spring 生态系统的 AI 集成框架，旨在简化 AI 功能（如机器学习、自然语言处理等）在 Spring 应用中的集成。

特点：

与 Spring 生态无缝集成：Spring AI 可以轻松集成到 Spring Boot 应用中，利用 Spring 的依赖注入、配置管理等特性。
模块化设计：支持多种 AI 功能模块，如 NLP、计算机视觉、推荐系统等。
简化开发：提供高级 API，降低开发者使用 AI 技术的门槛。
支持多种 AI 后端：可以与 TensorFlow、PyTorch、Hugging Face 等 AI 框架集成。

应用场景：

在 Spring 应用中集成机器学习模型。
构建智能推荐系统、聊天机器人等。
企业级 AI 应用开发。

2. LangChain

LangChain 是一个用于构建基于大语言模型（LLM）应用的框架，专注于链式调用和上下文管理。

特点：

链式调用：支持将多个 LLM 调用串联起来，形成复杂的任务流程。
上下文管理：能够管理对话上下文，支持多轮对话和记忆功能。
工具集成：可以与其他工具（如搜索引擎、数据库、API）集成，扩展 LLM 的能力。
模块化设计：提供 Prompt 模板、记忆模块、工具模块等，方便开发者定制。
多模型支持：支持 OpenAI、Hugging Face、Anthropic 等多种 LLM。

应用场景：

构建基于 LLM 的对话系统（如聊天机器人）。
开发复杂的 AI 工作流（如文档生成、数据分析）。
集成外部工具（如搜索引擎、数据库）以增强 LLM 功能。

LangChain 的使用和源码，请参见尼恩社群的资源：

3. LlamaIndex

LlamaIndex（原名 GPT Index）是一个专注于为 LLM 提供高效数据检索和索引的工具，旨在优化 LLM 对大规模数据的访问。

特点：

数据索引：为 LLM 提供高效的数据检索能力，支持对结构化、非结构化数据的索引。
上下文增强：通过索引技术，为 LLM 提供更相关的上下文信息，提升生成质量。
多数据源支持：支持从数据库、文档、API 等多种数据源中提取信息。
轻量级设计：专注于数据检索，易于与其他框架（如 LangChain）集成。

应用场景：

为 LLM 提供高效的数据检索能力。
构建基于 LLM 的知识库问答系统。
优化 LLM 对大规模数据的访问和生成。

对比总结

在这里插入图片描述

尼恩架构团队的大模型《LLM大模型学习圣经》

尼恩架构团队的大模型《LLM大模型学习圣经》是一个系列，包括下面的内容：

《Python学习圣经：从0到1精通Python，打好AI基础》
《LLM大模型学习圣经：从0到1吃透Transformer技术底座》
《LangChain学习圣经：从0到1精通LLM大模型应用开发的基础框架》
《LLM大模型学习圣经：从0到1精通RAG架构，基于LLM+RAG构建生产级企业知识库》
《SpringCloud + Python 混合微服务架构，打造AI分布式业务应用的技术底层》
《LLM大模型学习圣经：从0到1吃透大模型的顶级架构》
《LLM 智能体学习圣经：从0到1吃透 LLM 智能体的架构与实操》
《LLM 智能体学习圣经：从0到1吃透 LLM 智能体的中台架构与实操》

以上学习圣经的配套视频， 2025年 5月份之前发布。帮助大家成为：Java架构 + LLM 架构 = 多栖超级架构师

免费资料：小白 deepseek秒变高手！deepseek保姆级教程！

15天——从入门到精通deepseek , 加尼恩个人微信免费拿走

暗号，请在公众号后台发送消息：领电子书

DeepSeek 的模型文件，也可以从尼恩的网盘下载：

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

Spring 集成 DeepSeek 的 3大方法（史上最全）

本文 原始 地址

尼恩：LLM大模型学习圣经PDF的起源

Spring 整合 deepseek 模型 的三种方法

DeepSeek是什么？

先看DeepSeek发展历程

再来看DeepSeek 产品

DeepSeek 语言模型类

DeepSeek 数学- 语言模型类

DeepSeek 视觉 - 语言模型类

DeepSeek 其他模型

DeepSeek 和 其他主流开源模型的对比

主流开源 模型的 架构对比

性能表现的对比

训练成本的对比

应用场景的对比

混合专家（MoE）架构 和 Transformer 的架构的区别

结构组成的区别

设计理念 的区别

计算效率 的区别

Spring 整合 deepseek 模型 的三种方法

方法一：自定义 Client 集成DeepSeek

步骤 1：准备工作

步骤 2：添加依赖

步骤 3：配置 DeepSeek API

步骤 4：自定义 DeepSeek Client 客户端

步骤 5：创建 REST 控制器

步骤 6：运行和测试

示例响应

方法二：利用 spring-ai-openai 集成DeepSeek

步骤 1：添加依赖

步骤 2：配置 DeepSeek API

步骤 3：创建 Spring AI 客户端

步骤 4：创建 REST 控制器

步骤 5：运行和测试

示例响应

高级配置

调整生成参数

针对AI小白：什么是温度（Temperature）？

针对AI小白：最大 token 数（Max Tokens）

方法三：用Ollama 实现本地化部署 DeepSeek， Spring AI 的 spring-ai-ollama 模块访问 DeepSeek

什么是 Ollama？

步骤 1：安装 Ollama

步骤 2：添加 Spring AI Ollama 依赖

步骤 3：配置 Ollama

步骤 4：创建 Spring AI 客户端

步骤 5：创建 REST 控制器

步骤 6：运行和测试

通过 OllamaClient 调整生成参数

高级编程：通过chat API 接口 实现多轮对话

1. ChatClient.chat(message) 的核心功能

2. 多轮对话 相关的核心类和方法

Message 类

ChatResponse 类

ChatClient 接口

3. chat AIP的使用步骤

步骤 1：创建消息对象

步骤 2：调用 ChatClient.chat(message)

步骤 3：处理回复

4. 多轮对话示例

使用示例

Spring AI 到底好在哪？

Spring AI、LangChain 、 LlamaIndex 三大框架对标

1. Spring AI

本文原始地址

Spring 整合 deepseek 模型的三种方法

DeepSeek 和其他主流开源模型的对比

主流开源模型的架构对比

混合专家（MoE）架构和 Transformer 的架构的区别

设计理念的区别

计算效率的区别

Spring 整合 deepseek 模型的三种方法

方法三：用Ollama 实现本地化部署 DeepSeek， Spring AI 的 `spring-ai-ollama` 模块访问 DeepSeek

通过 `OllamaClient` 调整生成参数

高级编程：通过chat API 接口实现多轮对话

2. 多轮对话相关的核心类和方法