AI入门课

第01章_AI快速入门

第一节基础概念

1. AI简介

1) 什么是AI？

人工智能（AI）是通过计算机模拟人类智能（感知、推理、学习、决策），实现自主响应、问题解决的技术，核心是让机器“学会思考”，而非单纯执行指令。

2) AI的发展简史

起步：1956年达特茅斯会议，正式提出 “人工智能” 概念，AI 诞生。
低谷：1970-1990年代，两次 AI 寒冬，算力不足、算法受限、资金缩减，发展陷入停滞。
复苏：2006年深度学习提出，神经网络重新受到重视，AI 逐步回暖。
爆发：2020年后，大模型落地，ChatGPT、DeepSeek等产品问世，AI 全面落地应用。

3) AI的发展现状

发展现状：大模型主导，多场景落地；
核心突破：多模态融合（文本、图像、语音融合）、低成本部署；
现存问题：幻觉、算力依赖、伦理安全。

2. 相关名词

1) 大模型/Token

大模型：使用超大参数规模（百亿级以上）和海量数据训练的人工智能模型，能适配生成、问答、翻译等多种任务，常见产品如下：

模型名称	开发方	核心亮点	适用场景
GPT-5.2 Ultra	OpenAI	全能标杆，全模态，上下文 400K，推理 / 编程顶尖	复杂决策、科研、高要求代码
Claude Opus 4.6	Anthropic	旗舰级，100 万 token 上下文（beta），长推理 / 编码极强，安全稳定	超长篇文档、深度研究、企业级编码
Claude Sonnet 4.6	Anthropic	中杯旗舰，性能接近 Opus、价格更低，百万 token 上下文（beta），代码 / 长文优秀	日常专业场景、文档精读、代码开发、性价比首选
Gemini 3.1 Pro	Google	原生多模态（视频 / 3D），超长上下文，性价比高	视频处理、工业设计、海量文档
Llama 4	Meta	开源标杆，隐私强，社区成熟	私有化部署、企业二次开发
通义千问 Qwen3.5	阿里云	中文顶尖，多模态广，开源商用友好	多语言、音视频、企业应用
GLM-5	智谱 AI	推理效率高，多语言生态成熟	通用对话、内容创作、垂直落地
文心一言 5.0	百度	中文语义精准，产业应用成熟	政务 / 教育 / 金融私有化、工具调用
豆包 5.0	字节跳动	日常体验佳，生态融合紧密	个人助理、内容创作、短视频辅助
Kimi K2.5	月之暗面	长文本处理突出，国产长文能力领先	文献综述、长报告、大数据分析

Token： 就是文字被切分后的最小单位，模型按它来计费、算长度、限字数等，1 个汉字 ≈ 1 token，1 个单词 ≈ 1～3 token。。

2) Agent/Claw/Swarm

Agent：由提示词（Prompt）驱动，通过协同多种外部能力来完成复杂任务。
Claw：AI工具调用组件，负责对接外部工具；
Swarm：多Agent协同集群，分工完成复杂任务。

3) MCP/Skill/Plugin

MCP：模型上下文协议（Model Context Protocol, MCP）是连接智能体与外部世界能力的关键桥梁，允许智能体调用外部工具。当智能体接收到无法仅凭自身知识完成的任务时（例如查询实时天气），它会调用 MCP 来执行这些任务。
Skill：AI可调用的技能模块（如翻译、OCR）；
Plugin：插件，扩展AI功能（如联网、数据分析），可灵活增减。

4) FunctionCall/Embedding/RAG

FunctionCall：函数调用，让AI调用外部工具（如查天气、算数据），实现“思考+执行”；
Embedding：嵌入，将文本/图像转化为向量，用于语义匹配、检索；
RAG：知识检索增强 (Retrieval-Augmented Generation, RAG) 能够使智能体查询外部知识库，并将检索到的最相关的信息作为生成答案的直接依据。在处理私有知识或垂直领域问答时，RAG 能显著提升智能体的回答准确率，减少幻觉问题。

5) 其它补充

多模态：AI同时处理文本、图像、语音、视频等多种信息（如图文生成、语音转文字）；
Fine-tuning（微调）：基于预训练大模型，用少量特定数据训练，适配具体场景；
Prompt Engineering（提示词工程）：设计精准提示词，引导AI输出符合需求的结果；
对齐（Alignment）：让AI输出贴合人类价值观、需求，避免有害内容；
MoE（混合专家模型）：将大模型拆分为多个“专家模块”，分工处理不同任务，提升效率、降低算力成本。

3. 模型交互

1) Prompt Engine

提示词（Prompt）就是你发给 AI 的指令、问题、要求，用来告诉 AI 你想让它做什么、怎么做，分为：

系统提示词：是预设的元指令，用于定义其角色、行为准则与能力边界，以确保其在交互中始终保持一致性、可控性和任务合规性。
用户提示词：用户原始提问输入，代表用户向 AI 提出的问题、命令或陈述。

提示词优化的核心原则是：明确需求、限定范围、提供示例、指定格式等，一般格式为：背景 + 指令 + 要求，优化技巧如下：

避免模糊表述（如“写好一点”→“写300字、正式语气、突出核心亮点”）；
避免歧义，补充约束条件（如“不使用专业术语”“按时间顺序排列”）；
使用少样本提示（给出1-2个示例）或思维链提示（引导AI分步推理）；
避免提示词过于简略、未限定输出格式、未明确核心需求。

注意：
DeepSeek给出的提示词样例：https://api-docs.deepseek.com/zh-cn/prompt-library/

2) Context Engine

上下文（Context） 是模型交互中的记忆载体，决定了 AI 能否理解多轮对话的历史脉络与背景信息，是保持对话连贯性的核心机制。

系统上下文： 包含角色定义、能力边界、全局规则等元指令，贯穿整个会话周期；
对话历史： 按时间顺序排列的用户与 AI 的消息记录，通常以 role + content 形式存储；
外部上下文： 通过 RAG、FunctionCall 等注入的实时知识或工具返回结果。

上下文管理的核心原则是：控制长度、保留关键、及时压缩，常用策略如下：

窗口截断： 超出模型最大上下文长度（如 4K / 32K / 128K）时，丢弃最早的历史消息；
摘要压缩： 对过早的历史对话进行语义摘要，替换为精简的总结文本，释放 Token 空间；
分层记忆： 将会话级短期记忆与用户级长期记忆分离，结合向量数据库实现跨会话记忆召回；
关键信息锚定： 将重要的系统指令、用户偏好固定放在上下文头部，避免被截断丢失。

注意：
上下文越长，推理延迟和 Token 消耗越高，需在连贯性与成本之间权衡。

3) Harness Engine

Harness（模型编排引擎） 是连接应用层与底层模型的中间层，负责对多模型、多厂商的 API 进行统一封装、调度与治理，让上层业务代码以一致的方式调用不同的 AI 能力。

统一接口： 屏蔽底层模型差异（OpenAI、DeepSeek、通义千问等），提供标准化的 chat / stream / embed 调用方法；
模型路由： 根据任务类型（简单问答、复杂推理、代码生成）或模型状态（可用性、负载）自动选择最优模型；
流控与降级： 设置 QPS 限流、超时熔断，当主模型异常时自动切换至备用模型（Fallback），保障服务稳定性；
重试与容错： 对网络抖动、API 限流等异常进行指数退避重试，避免单点故障导致业务中断；
观测与审计： 记录每次调用的输入输出、延迟、Token 消耗，便于成本分析与问题追溯。

工程化配置通常包含：


1
# 示例：多模型路由与降级配置
2
ai:
3
  harness:
4
    providers:
5
      primary:
6
        model: qwen-max
7
        api-key: ${PRIMARY_KEY}
8
        timeout: 30s
9
      fallback:
10
        model: deepseek-chat
11
        api-key: ${FALLBACK_KEY}
12
        timeout: 60s
13
    rate-limit: 100  # 每秒最大请求数
14
    retry:
15
      max-attempts: 3
16
      backoff: 2s

注意：
Harness 层不处理业务逻辑，只负责模型调用的可靠性与一致性，应与业务层解耦。

4. 向量化

第二节理论基础

1. 理论基础01

1) 什么是深度学习？

深度学习是AI核心理论，基于神经网络（模拟人脑结构），通过多层网络实现特征提取、模式识别，是大模型的基础；

2) 深度学习与机器学习的区别?

数据依赖、特征提取方式等。

3) 神经网络结构

CNN（卷积神经网络）：适用于图像识别、提取空间特征；
RNN/LSTM（循环神经网络）：适用于序列数据（文本、语音），处理上下文关联；
Transformer：大模型核心结构（注意力机制），解决长文本依赖问题，提升并行计算效率。

4) 学习方式有哪些？

监督学习：有标签数据训练，如分类、回归；
无监督学习：无标签数据，自主挖掘规律，如聚类；
强化学习：通过“试错”学习，如AI下棋，核心是奖励机制；

5) 什么是过拟合和欠拟合？

过拟合：模型过度贴合训练数据，泛化能力差，通过正则化、数据增强解决；
欠拟合：模型未充分学习数据特征，预测不准），通过增加训练数据、加深模型层数解决。

6) 什么是注意力机制？

注意力机制是 Transformer 核心，让模型关注输入数据的关键部分（如文本中的重点词汇），提升处理效率和准确性；

第三节大模型

1. 大模型部署

1) 基于Ollma部署大模型

Ollama 是一款极简的本地大模型运行工具，只需简单命令即可在电脑上一键部署、离线运行各类开源 AI 大模型。

官网地址：https://ollama.com


x
1
# 安装Ollma
2
# 先从Ollma官网（https://ollama.com/）下载
3
OllamaSetup.exe /DIR=D:\study_setup\Ollama     # 指定目录安装（安装后进入软件修改模型位置）
4

5
# 查看 Ollama 版本
6
ollama --version
7

8
# 查看ollama进程是否启动
9
tasklist | findstr ollama
10

11
# 启动ollama
12
ollama start
13
ollama serve  # 重启
14

15
# 查看模型列表
16
ollama list     # 已安装的的
17
ollama ps       # 正在运行的
18

19
# 拉取（下载）模型
20
# 模型仓库：https://ollama.com/library
21
ollama pull qwen:7b
22
ollama pull deepseek-r1:14b
23

24
# 直接运行模型
25
ollama run qwen:7b     # 启动 Qwen 7B（4-bit量化）
26

27
# 停止运行中的模型
28
ollama stop llama3
29

30
# 删除不需要的模型
31
ollama rm llama3
32

33
# 访问模型
34
curl http://localhost:11434/api/chat \
35
  -d '{"model":"qwen:7b","messages":[{"role":"user","content":"你好"}]}'
36

2) 基于vLLM部署大模型

vLLM（Virtual Large Language Model）是伯克利大学开源的工业级高性能大语言模型（LLM）推理与服务引擎，以PagedAttention分页注意力技术为核心，极致优化显存与并发，是当前生产环境部署大模型的主流首选。


xxxxxxxxxx
41
1
# 1. 安装基础依赖
2
yum install -y git gcc gcc-c++ make
3

4
# 2. 安装 Conda（必须，用来管理 Python 3.11）
5
curl -fsSL https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh -o miniconda.sh
6
bash miniconda.sh -b -p ~/miniconda
7
source ~/miniconda/etc/profile.d/conda.sh
8

9
# 3. 创建 Python 3.11 环境（vLLM 唯一支持）
10
conda create -n vllm python=3.11 -y
11
conda activate vllm
12

13
# 4. 安装 CUDA 12.1 适配的 PyTorch + vLLM
14
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
15
pip install vllm==0.18.0 transformers==4.48.0 accelerate -U
16

17
# 5. 国内加速（解决下载慢）
18
export HF_ENDPOINT=https://hf-mirror.com
19

20
# 6. 启动 千问 Qwen2.5-7B 大模型 API
21
python -m vllm.entrypoints.openai.api_server \
22
--model Qwen/Qwen2.5-7B-Instruct \
23
--trust-remote-code \
24
--dtype auto \
25
--gpu-memory-utilization 0.9 \
26
--max-model-len 4096 \
27
--host 0.0.0.0 \
28
--port 8000
29

30
# 7. 验证是否启动成功
31
curl http://localhost:8000/v1/models
32

33
# 8. Python 调用代码
34
from openai import OpenAI
35
client = OpenAI(base_url="http://127.0.0.1:8000/v1", api_key="dummy")
36

37
resp = client.chat.completions.create(
38
    model="Qwen2.5-7B-Instruct",
39
    messages=[{"role":"user","content":"你好"}]
40
)
41
print(resp.choices[0].message.content)

2. 大模型微调

3. 大模型训练

第02章_AI工具使用

第一节 Claude Code

1. 安装部署

1) 什么是Claude Code？

Claude Code 是一款智能编码工具，能够读取你的代码库、编辑文件、执行命令，并与你的开发工具集成。

官方文档：https://code.claude.com/docs/en/overview。

笔记参考：https://cloud.fynote.com/share/d/HnIGGVKAMH

2) 命令行安装


xxxxxxxxxx
52
1
# 1. 连接VPN美国节点
2
[略]
3

4
# 2.下载和执行安装脚本
5
curl -fsSL https://claude.ai/install.sh | bash
6

7
# 3. 配置环境变量
8
PATH C:\Users\Administrator\.local\bin
9
CLAUDE_CODE_GIT_BASH_PATH D:\Application\Git\bin   # 优先配置bash.exe路径到PATH，不配置这个
10

11
# 4. 启动和登录
12
claude
13
/login
14

15
# 5. 使用国产大模型
16
# step1：修改 C:\Users\%USERNAME%\.claude.json    
17
{
18
  "hasCompletedOnboarding": true
19
}
20

21
# step2：修改 C:\Users\%USERNAME%\.claude\settings.json
22
{
23
  "env": {
24
    "ANTHROPIC_BASE_URL": "https://open.bigmodel.cn/api/anthropic",
25
    "ANTHROPIC_API_KEY": "从智谱官网获取",
26
    "API_TIMEOUT_MS": "3000000",
27
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
28
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "glm-4.5-air",
29
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "glm-4.6v",
30
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "glm-5"
31
  },
32
  "autoUpdatesChannel": "latest"
33
}
34

35
# 也可通过环境变量方式配置
36
# 智谱
37
ANTHROPIC_API_KEY：从智谱官网获取
38
ANTHROPIC_BASE_URL：https://open.bigmodel.cn/api/anthropic
39
ANTHROPIC_MODEL：GLM-4.7
40
# 阿里百炼
41
ANTHROPIC_API_KEY：从阿里百炼官网获取
42
ANTHROPIC_BASE_URL：https://coding.dashscope.aliyuncs.com/apps/anthropic
43
ANTHROPIC_MODEL：qwen3.5-plus
44
# DeepSeek
45
$env:ANTHROPIC_BASE_URL="https://api.deepseek.com/anthropic"
46
$env:ANTHROPIC_AUTH_TOKEN="<你的 DeepSeek API Key>"
47
$env:ANTHROPIC_MODEL="deepseek-v4-pro[1m]"
48
$env:ANTHROPIC_DEFAULT_OPUS_MODEL="deepseek-v4-pro[1m]"
49
$env:ANTHROPIC_DEFAULT_SONNET_MODEL="deepseek-v4-pro[1m]"
50
$env:ANTHROPIC_DEFAULT_HAIKU_MODEL="deepseek-v4-flash"
51
$env:CLAUDE_CODE_SUBAGENT_MODEL="deepseek-v4-flash"
52
$env:CLAUDE_CODE_EFFORT_LEVEL="max"

3) 插件安装

在各大插件市场搜索安装即可，推荐一个 CC GUI 插件如下，可手工加载C:\Users\用户名\.claude\settings.json配置。

2. 基本使用

1) 基本命令


xxxxxxxxxx
20
1
# 启动 Claude Code
2
claude                # 正常启动
3
claude -c             # 启动并加载最近会话
4

5
# 核心模式切换（日常高频）
6
shift+tab             # 切换交互模式（默认/规划/代理/自动）
7
  - 默认模式：手动确认每个操作（最安全）
8
  - 规划模式：仅生成计划，需审批执行
9
  - 代理模式：自动接受文件编辑/创建
10
  - 自动模式：无权限校验，谨慎使用
11

12
# 输入快捷键
13
shift+回车            # 多行输入（换行不发送）
14
ctrl+g                # 打开内置编辑器输入长文本
15
直接拖入/粘贴图片      # 快速上传图片（无需命令）
16

17
# 直接执行终端命令（高频）
18
!ls                   # 执行 ls
19
!npm install          # 执行任意终端命令
20
!python test.py       # 运行代码

2) 会话管理


xxxxxxxxxx
11
1
# 会话上下文
2
ctrl+o                # 查看当前会话上下文
3
/compact              # 压缩上下文（减少token占用）
4
/compact 总结代码修改  # 带提示压缩
5
/clear                # 清空会话上下文
6
esc esc               # 快速回滚会话
7

8
# 会话任务
9
/resume               # 重载/恢复最近会话
10
/tasks                # 查看当前会话所有任务
11
ctrl+b                # 将当前任务放入后台运行

3) 文件 / 项目操作


xxxxxxxxxx
15
1
# 文件查看
2
/tree                 # 生成项目目录树
3
/files                # 列出项目文件
4
/file 路径            # 查看文件完整内容
5
/diff                 # 查看文件修改对比
6

7
# 文件编辑
8
/edit 路径            # 编辑指定文件
9
/undo                 # 撤销上一次文件修改
10
/save 路径            # 保存内容到文件
11

12
# 代码工具
13
/format               # 自动格式化代码
14
/lint                 # 代码语法检查
15
/fix                  # 自动修复代码错误

3) 高级扩展


xxxxxxxxxx
18
1
# 项目配置文件
2
/init                 # 初始化/管理 CLAUDE.MD
3
/memory               # 打开 CLAUDE.MD（项目级+用户级）
4

5
# MCP 服务管理
6
/mcp                  # 查看所有MCP服务
7
mcp add --transport http figma https://mcp.figma.com/mcp
8
mcp remove figma      # 移除MCP服务（修正原命令错误）
9

10
# 技能管理（~/.claude/skills/技能名称/SKILLS.MD）
11
/skills              # 查看所有技能
12
/技能名 提示词        # 使用指定技能
13

14
# 子代理 & 钩子 & 插件
15
/hooks                # 管理钩子函数
16
/agent                # 管理 SubAgent
17
/plugin               # 管理插件（插件是对skills、subagent、hooks、mcp等的打包）
18

注意：
skills会继承主Agent上下文，而SubAgent不会影响当前上下文，适合关联小，影响大的任务。

4) Skill示例

下面是一个文件整理技能，在技能目录~/.claude/skills/技能名称/SKILLS.MD创建SKILLS.MD文件，写入下面内容即可。


xxxxxxxxxx
16
1
---
2
name: file_organizer
3
description: 自动整理指定目录下的文件，按扩展名分类到不同文件夹。
4
requires: [“bash”]
5
---
6

7
# 文件整理技能
8

9
当用户要求整理某个目录时，请执行以下操作：
10

11
1.  使用 `bash` 工具，在用户指定的目标目录中，创建 `Images`、`Documents`、`Archives` 子文件夹。
12
2.  将所有的 `.jpg`、`.png` 文件移动到 `Images` 文件夹。
13
3.  将所有的 `.pdf`、`.docx` 文件移动到 `Documents` 文件夹。
14
4.  将所有的 `.zip`、`.tar.gz` 文件移动到 `Archives` 文件夹。
15
5.  操作完成后，向用户报告整理结果。
16

3. 其它AI编程工具

1) Cursor

Cursor 是由 Anysphere 公司开发、基于 VS Code 深度定制的 AI 原生代码编辑器，核心定位是 “AI 结对编程伙伴”。

它集成了 GPT-4、Claude、Gemini 等大模型，支持自然语言编程、项目级代码理解、跨文件智能重构、一键 Debug 与优化，并具备 Agent 自主执行、Yolo 快速编辑等高级模式，能直接通过对话生成、修改、解读与维护代码。

官网地址：https://cursor.com/cn

2) Trce

Trae（读作 /treɪ/） IDE是由字节跳动推出的一款 AI 原生集成开发环境的IDE，集成了智能问答、实时代码建议、代码片段生成及基于智能体的自动编程能力，并针对中文开发者进行了深度优化，例如全界面中文支持和语义理解优化。

官网地址：https://www.trae.cn/

笔记参考：https://cloud.fynote.com/share/d/iISJVVge

3) Open Code

4) Codex

5) Qorder


xxxxxxxxxx
44
1
# Windows安装
2
npm install -g @qoder-ai/qodercli
3

4
# 启动与基础信息
5
qodercli                  # 启动交互式TUI模式
6
qodercli --version        # 查看版本{insert\_element\_0\_}
7
qodercli update           # 升级CLI{insert\_element\_1\_}
8
qodercli -w /path/to/dir  # 指定工作目录启动{insert\_element\_2\_}
9
qodercli -p "提示内容"    # 单轮命令模式执行提示
10

11
# 登录与账户
12
/login                    # 登录账号{insert\_element\_3\_}
13
/logout                   # 退出登录
14
/usage                    # 查看账户、Credits消耗
15

16
# 帮助与状态
17
/help                     # 显示帮助{insert\_element\_4\_}
18
/status                   # 查看CLI状态（版本、模型、API等）
19
/config                   # 管理CLI配置{insert\_element\_5\_}
20
/release-notes            # 查看更新日志
21

22
# 项目与记忆
23
/init                     # 初始化/更新AGENTS.md{insert\_element\_6\_}
24
/memory                   # 编辑AGENTS.md{insert\_element\_7\_}
25

26
# 代码与任务
27
/review                   # 代码评审本地改动{insert\_element\_8\_}
28
/quest                    # 基于Spec委派任务{insert\_element\_9\_}
29
/code-inspect             # 代码检查（示例）
30

31
# 会话与上下文
32
/clear                    # 清空当前会话上下文{insert\_element\_10\_}
33
/compact                  # 压缩/总结上下文{insert\_element\_11\_}
34
/resume                   # 查看/恢复历史会话{insert\_element\_12\_}
35
/export 文件名            # 导出当前会话{insert\_element\_13\_}
36

37
# 工具与后台
38
/agents                   # 子Agent管理
39
/bashes                   # 查看后台Bash任务
40
/vim                      # 外部编辑器编辑输入
41

42
# 其他
43
/feedback 内容            # 提交反馈{insert\_element\_14\_}
44
/quit                     # 退出TUI

第二节 OpenClaw

1. 安装部署

1) 什么是OpenClaw？

OpenClaw 是一款开源 AI 智能体，可部署在本地电脑，通过 Telegram、微信等聊天软件操控，让 AI 不仅能对话建议，更能主动执行代码、管理文件、操作浏览器等实际任务，成为真正"能动手"的私人数字助理。

官网地址：https://openclaw.ai/

官方文档：https://docs.openclaw.ai/zh-CN

笔记参考：https://cloud.fynote.com/share/d/ZAHaTUrAC

2) Windows安装


xxxxxxxxxx
28
1
# 参考：https://docs.bigmodel.cn/cn/guide/develop/openclaw
2

3
# 1. 解锁 PowerShell 执行策略（必做）
4
#    按 Win+S，搜索 PowerShell，右键选择「以管理员身份运行」，UAC 点「是」
5
Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser
6

7
# 2. 执行官方一键安装
8
#    关闭管理员 PowerShell，打开普通权限 PowerShell 执行
9
#    脚本会自动安装 Node.js 22、配置环境变量、安装 OpenClaw 并完成初始化
10
iwr -useb https://openclaw.ai/install.ps1 | iex              # 官方
11
iwr -useb https://open-claw.org.cn/install-cn.ps1 | iex      # 国内加速
12

13
# 3. 新手引导
14
#    运行上述安装命令后，配置过程将自动开始。如果没有开始，您可以运行以下命令开始配置
15
openclaw onboard --install-daemon
16

17
# 4. 验证安装
18
openclaw --version  # 输出版本号
19
openclaw doctor     # 检查配置问题
20
openclaw status     # 查看状态
21

22
# 5. 修改配置（如配置模型key等）
23
openclaw config
24

25
# 6. 启动服务（普通权限的 PowerShell）
26
openclaw gateway run   # 启动 Gateway 服务
27
openclaw dashboard     # 启动 WebUI 仪表盘
28

3) Linux安装


xxxxxxxxxx
7
1
# 一键安装
2
curl -fsSL https://openclaw.ai/install.sh | bash
3

4
# 验证与初始化
5
openclaw --version
6
openclaw onboard --install-daemon
7

2. 基本使用

1) 常用命令


xxxxxxxxxx
42
1
# 基础与配置
2
openclaw onboard              # 初始化向导
3
openclaw configure            # 交互式配置
4
openclaw config set <key> <val> # 设置配置项
5
openclaw config get <key>     # 获取配置
6
openclaw config unset <key>   # 删除配置
7
openclaw doctor               # 健康检查
8
openclaw doctor --fix         # 自动修复
9
openclaw status               # 系统状态
10
openclaw update               # 更新OpenClaw
11
openclaw logs --follow        # 实时日志
12

13
# Gateway服务
14
openclaw gateway start         # 后台启动
15
openclaw gateway stop          # 停止
16
openclaw gateway restart       # 重启
17
openclaw gateway status        # 状态
18
openclaw gateway run --dev     # 前台调试
19
openclaw gateway install       # 安装系统服务（开机自启）
20

21
# 模型管理
22
openclaw models list           # 列出模型
23
openclaw models set <model>    # 设置默认模型
24
openclaw models status         # 模型状态
25

26
# 渠道管理
27
openclaw channels list         # 渠道列表
28
openclaw channels status       # 渠道状态
29
openclaw channels login <name> # 登录渠道
30

31
# Skill管理
32
openclaw skills list           # 已装技能
33
openclaw skills check          # 检查技能
34
openclaw skills refresh        # 刷新技能
35

36
# 会话（TUI内）
37
/new                          # 新会话
38
/status                       # 会话状态
39
/think high|medium|off        # 思考深度
40
/elevated full|ask            # 提权模式
41
/export-session <path>        # 导出会话
42
/kill <agent-id>              # 终止子代理

2) 修改大模型


xxxxxxxxxx
32
1
# 命令行切换（推荐）
2
openclaw models set moonshot/kimi-latest  # 设置默认
3
openclaw models set ollama/qwen2.5:7b     # 本地Ollama
4

5
# 配置文件（~/.openclaw/openclaw.json）
6
{
7
  "agents": {
8
    "defaults": {
9
      "model": {
10
        "primary": "moonshot/kimi-latest",
11
        "fallbacks": ["doubao/seed-2.0-lite", "ollama/qwen2.5:7b"]
12
      }
13
    }
14
  },
15
  "models": {
16
    "providers": {
17
      "moonshot": {
18
        "baseUrl": "https://api.moonshot.cn/v1",
19
        "apiKey": "sk-xxx",
20
        "models": [{"id": "kimi-latest", "name": "Kimi"}]
21
      },
22
      "ollama": {
23
        "baseUrl": "http://localhost:11434/v1",
24
        "apiKey": "ollama",
25
        "models": [{"id": "qwen2.5:7b", "name": "Qwen2.5"}]
26
      }
27
    }
28
  }
29
}
30

31
# 生效
32
openclaw gateway restart

3) 配置渠道


xxxxxxxxxx
34
1
# 飞书
2
openclaw channels login feishu
3
# 输入 appId、appSecret、encryptKey
4

5
# 企业微信
6
openclaw channels login wecom
7
# 输入 corpId、agentId、secret
8

9
# 钉钉
10
openclaw channels login dingtalk
11
# 输入 clientId、clientSecret
12

13
# QQ
14
openclaw channels login qq
15
# 输入 appId、token
16

17
# Telegram
18
openclaw channels login telegram
19
# 输入 botToken
20

21
# 配置文件示例（~/.openclaw/openclaw.json）
22
{
23
  "channels": {
24
    "feishu": {
25
      "enabled": true,
26
      "appId": "xxx",
27
      "appSecret": "xxx",
28
      "encryptKey": "xxx"
29
    }
30
  }
31
}
32

33
# 生效
34
openclaw gateway restart

4) 添加SKILL


xxxxxxxxxx
26
1
# ClawHub安装（推荐）
2
npx clawhub@latest install tavily-search    # 联网搜索
3
npx clawhub@latest install summarize        # 文本总结
4
npx clawhub@latest install gog              # Google办公
5
npx clawhub@latest install obsidian         # Obsidian笔记
6
npx clawhub@latest install system-utils     # 系统工具
7

8
# 批量/更新
9
clawhub update --all                       # 更新所有
10
clawhub sync --all                          # 同步
11

12
# 手动安装
13
mkdir -p ~/.openclaw/workspace/skills/hello
14
cat > ~/.openclaw/workspace/skills/hello/SKILL.md << 'EOF'
15
---
16
name: hello
17
description: 打招呼
18
---
19
# Hello Skill
20
用户说你好时回复：Hello from OpenClaw!
21
EOF
22

23
# 生效
24
openclaw skills refresh
25
# 或
26
openclaw gateway restart

第三节 DALL.E3

第四节 Midjourney

第五节 Dify

Dify：面向企业级用户的开源 AI 平台，支持主流大模型（如 GPT‑4、Claude）、灵活创建聊天机器人、文本应用和复杂工作流，允许私有化部署、更好地保障数据隐私和合规性。

Coze：针对个人或小型团队构建对话式 AI 应用的低/无代码平台，支持国内模型、一键页面布局、丰富插件嵌入、云端托管（依赖火山引擎），适合快速验证智能体/聊天机器人产品。

mauns：全自主、多代理驱动的智能体平台，擅长接收高层指令后自动拆解任务、调用多模型及 API（浏览网页、写代码、生成报告/部署网站等），适合跨域、多步骤、复杂任务的专业用户或团队使用。

第六节 milvus

1. 安装部署

1) 什么是milvus？

Milvus 是一个由 Zilliz 开发的高性能向量数据库，专为存储、索引和检索高维向量数据而设计，它能够处理图像、音频、视频、自然语言等嵌入表示（embeddings），支持海量向量（万亿级）毫秒级相似搜索，现已成为世界领先的开源向量数据库项目之一。

2) 安装milvus

Milvus Standalone: Docker 中运行，所有组件（Milvus + etcd）打包在一台主机内，支持10亿向量存储，适合中小型生产环境。


xxxxxxxxxx
15
1
#创建目录并进入【创建目录，然后一会docker-compose.yml就会下载在这里】
2
mkdir -p /root/dockerrepos/milvus && cd /root/dockerrepos/milvus
3

4
#下载compose 配置,或者直接将资料中 docker-compose.yml上传至目录下
5
wget https://github.com/milvus-io/milvus/releases/download/v2.5.14/milvus-standalone-docker-compose.yml -O docker-compose.yml
6

7
# 启动 Milvus
8
docker compose up -d
9

10
# 停止Milvus
11
docker compose down
12

13
# 访问 Web UI
14
http://119.29.250.81:9091/webui/    
15

Attu：一款专为 Milvus 向量数据库打造的开源数据库管理工具，提供了便捷的图形化界面，简化了操作与管理流程。

2. 基本使用

1) 导入依赖


xxxxxxxxxx
10
1
<dependency>
2
  <groupId>org.slf4j</groupId>
3
  <artifactId>slf4j-api</artifactId>
4
  <version>2.0.9</version>
5
</dependency>
6
<dependency>
7
  <groupId>io.milvus</groupId>
8
  <artifactId>milvus-sdk-java</artifactId>
9
  <version>2.6.0</version>
10
</dependency>

2) 创建Collection和Schema

Collection：可以比作 MySql 中的表，是 Milvus 中最大的数据单元，有行和列的概念，每列代表一个字段，每行代表一个实体。
Schema：定义了 Collections 的数据结构，必须包含的 3 类字段：
- 主键字段：必须有，且只能 1 个，唯一标识一条数据，类型：int /varchar。
- 向量字段：必须有，最多 4 个，存文章、图片、音频转成的向量，用来做相似度检索，必须指定向量维度（dim）。
- 标量字段：可选，任意多个，存文本、数字、布尔、JSON等普通数据，用来过滤或筛选（比如：分类、时间、作者、状态）。


xxxxxxxxxx
86
1
package com.allyun.controller;
2

3
import io.milvus.v2.client.ConnectConfig;
4
import io.milvus.v2.client.MilvusClientV2;
5
import io.milvus.v2.common.DataType;
6
import io.milvus.v2.common.IndexParam;
7
import io.milvus.v2.service.collection.request.AddFieldReq;
8
import io.milvus.v2.service.collection.request.CreateCollectionReq;
9
import java.util.ArrayList;
10
import java.util.List;
11

12
public class TestMilvusCollection {
13
    static String MILVUS_URI = "http://192.168.1.3:19530";
14
    static String TOKEN = "root:Milvus";
15

16

17
    public static void main(String[] args) {
18

19
        //1.连接到Milvus
20
        ConnectConfig connectConfig = ConnectConfig.builder()
21
                .uri(MILVUS_URI)
22
                .token(TOKEN)
23
                .build();
24
        MilvusClientV2 client = new MilvusClientV2(connectConfig);
25

26

27
        //2.创建 Collection
28
        String collectionName = "testCollection";
29

30
        createCollection(client,collectionName);
31

32
        //3.列出collection
33
        List<String> collectionNames = client.listCollections().getCollectionNames();
34
        System.out.println("collectionNames:"+collectionNames);
35

36
    }
37

38

39
    private static void createCollection(MilvusClientV2 client, String collectionName) {
40
        //1.创建schema
41
        CreateCollectionReq.CollectionSchema schema = MilvusClientV2.CreateSchema()
42
                .addField(
43
                        AddFieldReq.builder()
44
                                .fieldName("id")
45
                                .dataType(DataType.Int64)
46
                                .isPrimaryKey(true)
47
                                .autoID(false)
48
                                .build()
49
                )
50
                .addField(
51
                        AddFieldReq.builder()
52
                                .fieldName("vector")
53
                                .dataType(DataType.FloatVector)
54
                                .dimension(5)
55
                                .build()
56
                )
57
                .addField(
58
                        AddFieldReq.builder()
59
                                .fieldName("color")
60
                                .dataType(DataType.VarChar)
61
                                .maxLength(512)
62
                                .build()
63
                );
64

65
        //2. 构建索引
66
        ArrayList<IndexParam> indexParams = new ArrayList<IndexParam>();
67

68
        IndexParam vector = IndexParam.builder()
69
                .fieldName("vector")
70
                .indexType(IndexParam.IndexType.IVF_FLAT)
71
                .metricType(IndexParam.MetricType.COSINE)/
72
                .build();
73
        indexParams.add(vector);
74

75
        //创建collection
76
        client.createCollection(
77
                CreateCollectionReq.builder()
78
                        .collectionName(collectionName)
79
                        .collectionSchema(schema)
80
                        .indexParams(indexParams)
81
                        .build()
82
        );
83

84
    }
85
}
86

3) 数据增删查


xxxxxxxxxx
144
1
import com.google.gson.Gson;
2
import com.google.gson.JsonObject;
3
import io.milvus.v2.client.ConnectConfig;
4
import io.milvus.v2.client.MilvusClientV2;
5
import io.milvus.v2.common.DataType;
6
import io.milvus.v2.common.IndexParam;
7
import io.milvus.v2.service.collection.request.AddFieldReq;
8
import io.milvus.v2.service.collection.request.CreateCollectionReq;
9
import io.milvus.v2.service.utility.request.FlushReq;
10
import io.milvus.v2.service.vector.request.DeleteReq;
11
import io.milvus.v2.service.vector.request.GetReq;
12
import io.milvus.v2.service.vector.request.InsertReq;
13
import io.milvus.v2.service.vector.response.DeleteResp;
14
import io.milvus.v2.service.vector.response.GetResp;
15
import io.milvus.v2.service.vector.response.InsertResp;
16
import io.milvus.v2.service.vector.response.QueryResp;
17

18
import java.util.ArrayList;
19
import java.util.Arrays;
20
import java.util.List;
21

22
public class TestMilvusCollection4 {
23
    static String MILVUS_URI = "http://192.168.0.108:19530";
24
    static String TOKEN = "root:Milvus";
25

26

27
    public static void main(String[] args) {
28

29
        // 1.连接到Milvus
30
        ConnectConfig connectConfig = ConnectConfig.builder()
31
                .uri(MILVUS_URI)
32
                .token(TOKEN)
33
                .build();
34

35
        MilvusClientV2 client = new MilvusClientV2(connectConfig);
36

37

38
        // 2.向collection插入数据
39
        String collectionName = "testCollection";
40
        inserDataIntoCollection(client,collectionName);
41
        
42
        // 3.查询数据
43
        GetResp getResp = client.get(
44
                GetReq.builder()
45
                        .collectionName(collectionName)
46
                        .ids(List.of(1, 2, 3))
47
                        .outputFields(List.of("id", "color"))
48
                        .build()
49
        );
50
        for (QueryResp.QueryResult getResult : getResp.getResults) {
51
            System.out.println("数据："+getResult.toString());
52
        }
53
        
54
        // 4.删除数据
55
        DeleteResp delete = client.delete(DeleteReq.builder().collectionName(collectionName).ids(List.of(0, 1)).build());
56
        System.out.println("delete:"+delete);
57
    }
58

59
    private static void inserDataIntoCollection(MilvusClientV2 client, String collectionName) {
60
        //准备数据
61
        Gson gson = new Gson();
62
        List<JsonObject> data = Arrays.asList(
63
                gson.fromJson("{\"id\": 0, \"vector\": [0.3580376395471989, -0.6023495712049978, 0.18414012509913835, -0.26286205330961354, 0.9029438446296592], \"color\": \"pink_1111\"}", JsonObject.class),
64
                gson.fromJson("{\"id\": 1, \"vector\": [0.19886812562848388, 0.06023560599112088, 0.6976963061752597, 0.2614474506242501, 0.838729485096104], \"color\": \"red_7025\"}", JsonObject.class),
65
                gson.fromJson("{\"id\": 2, \"vector\": [0.43742130801983836, -0.5597502546264526, 0.6457887650909682, 0.7894058910881185, 0.20785793220625592], \"color\": \"orange_6781\"}", JsonObject.class),
66
                gson.fromJson("{\"id\": 3, \"vector\": [0.3172005263489739, 0.9719044792798428, -0.36981146090600725, -0.4860894583077995, 0.95791889146345], \"color\": \"pink_9298\"}", JsonObject.class),
67
                gson.fromJson("{\"id\": 4, \"vector\": [0.4452349528804562, -0.8757026943054742, 0.8220779437047674, 0.46406290649483184, 0.30337481143159106], \"color\": \"red_4794\"}", JsonObject.class),
68
                gson.fromJson("{\"id\": 5, \"vector\": [0.985825131989184, -0.8144651566660419, 0.6299267002202009, 0.1206906911183383, -0.1446277761879955], \"color\": \"yellow_4222\"}", JsonObject.class),
69
                gson.fromJson("{\"id\": 6, \"vector\": [0.8371977790571115, -0.015764369584852833, -0.31062937026679327, -0.562666951622192, -0.8984947637863987], \"color\": \"red_9392\"}", JsonObject.class),
70
                gson.fromJson("{\"id\": 7, \"vector\": [-0.33445148015177995, -0.2567135004164067, 0.8987539745369246, 0.9402995886420709, 0.5378064918413052], \"color\": \"grey_8510\"}", JsonObject.class),
71
                gson.fromJson("{\"id\": 8, \"vector\": [0.39524717779832685, 0.4000257286739164, -0.5890507376891594, -0.8650502298996872, -0.6140360785406336], \"color\": \"white_9381\"}", JsonObject.class),
72
                gson.fromJson("{\"id\": 9, \"vector\": [0.5718280481994695, 0.24070317428066512, -0.3737913482606834, -0.06726932177492717, -0.6980531615588608], \"color\": \"purple_4976\"}", JsonObject.class)
73
        );
74

75
        //插入数据
76
        InsertResp insert = client.insert(
77
                InsertReq.builder()
78
                        .collectionName(collectionName)
79
                        .data(data)
80
                        .build()
81
        );
82

83
        //刷新数据，否则查询不到数据
84
        client.flush(
85
                FlushReq.builder()
86
                        .collectionNames(List.of(collectionName))
87
                        .build()
88
        );
89

90
        System.out.println("插入数据成功");
91

92

93

94
    }
95

96
    private static void createCollection(MilvusClientV2 client, String collectionName) {
97
        //1.创建schema
98
        CreateCollectionReq.CollectionSchema schema = MilvusClientV2.CreateSchema()
99
                .addField(
100
                        AddFieldReq.builder()
101
                                .fieldName("id")
102
                                .dataType(DataType.Int64)
103
                                .isPrimaryKey(true)
104
                                .autoID(false)
105
                                .build()
106
                )
107
                .addField(
108
                        AddFieldReq.builder()
109
                                .fieldName("vector")
110
                                .dataType(DataType.FloatVector)
111
                                .dimension(5)
112
                                .build()
113
                )
114
                .addField(
115
                        AddFieldReq.builder()
116
                                .fieldName("color")
117
                                .dataType(DataType.VarChar)
118
                                .maxLength(512)
119
                                .build()
120
                );
121

122
        //构建索引
123
        ArrayList<IndexParam> indexParams = new ArrayList<IndexParam>();
124

125
        IndexParam vector = IndexParam.builder()
126
                .fieldName("vector")
127
                .indexType(IndexParam.IndexType.IVF_FLAT)
128
                .metricType(IndexParam.MetricType.COSINE)
129
                .build();
130
        indexParams.add(vector);
131

132
        //创建collection
133
        client.createCollection(
134
                CreateCollectionReq.builder()
135
                        .collectionName(collectionName)
136
                        .collectionSchema(schema)
137
                        .indexParams(indexParams)
138
                        .build()
139
        );
140

141
    }
142
}
143

144

3. 其它向量数据库

1) Redis Stack

第03章_AI应用开发

第一节 SpringAI

1. SpringAI简介

1) 什么是Spring AI？

SpringAI是一个AI工程领域的应用程序框架，对OpenAI、DeepSeek等主流 AI 大模型提供了支持。

官网地址：https://spring.io/projects/spring-ai

2. 接入DeepSeek

1) 引入依赖


xxxxxxxxxx
55
1
<!-- 继承SpringBoot父工程：spring-boot-starter-parent -->
2
<parent>
3
    <groupId>org.springframework.boot</groupId>
4
    <artifactId>spring-boot-starter-parent</artifactId>
5
    <version>3.4.3</version>
6
</parent>
7

8
<!-- 使用JDK17+版本编译 -->
9
<properties>
10
    <maven.compiler.source>17</maven.compiler.source>
11
    <maven.compiler.target>17</maven.compiler.target>
12
    <spring-ai.version>1.0.0-M5</spring-ai.version>
13
    <spring-ai-alibaba.version>1.0.0-M6.1</spring-ai-alibaba.version>
14
</properties>
15

16
<!-- 依赖 -->
17
<dependencies>
18
    <!-- SpringBoot Web模块 -->
19
    <dependency>
20
        <groupId>org.springframework.boot</groupId>
21
        <artifactId>spring-boot-starter-web</artifactId>
22
    </dependency>
23

24
    <!-- Spring AI 集成 OpenAi/DeepSeek -->
25
    <dependency>
26
        <groupId>group.springframework.ai</groupId>
27
        <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
28
    </dependency>
29
    
30
    <!-- SpringBoot 测试模块 -->
31
    <dependency>
32
        <groupId>org.springframework.boot</groupId>
33
        <artifactId>spring-boot-test</artifactId>
34
    </dependency>
35

36
    <!-- lombok -->
37
    <dependency>
38
        <groupId>org.projectlombok</groupId>
39
        <artifactId>lombok</artifactId>
40
    </dependency>
41
</dependencies>
42

43
<!-- 依赖管理 -->
44
<dependencyManagement>
45
    <dependencies>
46
        <!-- Spring AI 依赖管理 -->
47
        <dependency>
48
            <groupId>group.springframework.ai</groupId>
49
            <artifactId>spring-ai-bom</artifactId>
50
            <version>${spring-ai.version}</version>
51
            <type>pom</type>
52
            <scope>import</scope>
53
        </dependency>
54
    </dependencies>
55
</dependencyManagement>

2) 创建配置文件


xxxxxxxxxx
18
1
# application.yml
2

3
# 服务器配置
4
server:
5
  port: 8080
6

7
# Spring配置
8
spring:
9
  application:
10
    name: SpringAI-demo
11
  ai:
12
    # DeepSeek配置
13
    openai:
14
      base-url: https://api.deepseek.com
15
      api-key: sk-04b52cab40d7443486c24a7a09691ec9
16
      chat:
17
        options:
18
          model: deepseek-chat

3) 编写Controller


xxxxxxxxxx
52
1
/**
2
 * Sping AI 接入 OpenAI/DeepSeek 模型
3
 */
4
@RestController
5
@RequestMapping("/deepseek")
6
public class DeepSeekClientModelController {
7

8
    /**
9
     * OpenAi/DeepSeek 对话模型客户端
10
     */
11
    @Autowired
12
    private OpenAiChatModel openAiChatModel;
13

14
    /**
15
     * 接入DeepSeek对话模型 deepseek-chat
16
     *
17
     * @param msg
18
     * @return
19
     */
20
    @GetMapping("/chat")
21
    public String chat(@RequestParam(defaultValue = "你是谁？") String msg) {
22
        // 构建提示词
23
        Prompt prompt = new Prompt(msg, OpenAiChatOptions.builder()
24
                .withModel("deepseek-chat")
25
                .withTemperature(0.8F)
26
                .build());
27

28
        // 对话
29
        ChatResponse chatResponse = openAiChatModel.call(prompt);
30
        return chatResponse.getResult().getOutput().getContent();
31
    }
32

33
    /**
34
     * 接入DeepSeek流式对话模型 deepseek-chat
35
     *
36
     * @param msg
37
     * @return
38
     */
39
    @GetMapping(value = "/stream", produces = "text/html;charset=UTF-8")
40
    public Flux<String> stream(@RequestParam(defaultValue = "你是谁？") String msg) {
41
        // 构建提示词
42
        Prompt prompt = new Prompt(msg, OpenAiChatOptions.builder()
43
                .withModel("deepseek-chat")
44
                .withTemperature(0.8F)
45
                .build());
46

47
        // 对话
48
        Flux<ChatResponse> chatResponseFlux = openAiChatModel.stream(prompt);
49
        return chatResponseFlux.map((r) -> r.getResult() != null && r.getResult().getOutput() != null && r.getResult().getOutput().getContent() != null ? r.getResult().getOutput().getContent() : "").filter(StringUtils::hasText);
50
    }
51

52
}

4) 创建启动类


xxxxxxxxxx
9
1
/**
2
 * 启动类
3
 */
4
@SpringBootApplication(exclude = ContextFunctionCatalogAutoConfiguration.class)
5
public class DeepSeekApplication {
6
    public static void main(String[] args) {
7
        SpringApplication.run(DeepSeekApplication.class, args);
8
    }
9
}

5) 测试

3. 接入阿里百炼平台

1) 引入依赖


xxxxxxxxxx
6
1
<!-- Spring AI 集成 千问模型 -->
2
<dependency>
3
    <groupId>com.alibaba.cloud.ai</groupId>
4
    <artifactId>spring-ai-alibaba-starter</artifactId>
5
    <version>${spring-ai-alibaba.version}</version>
6
</dependency>

2) 修改配置


xxxxxxxxxx
15
1
spring:
2
  ai:
3
    # 阿里百炼
4
    dashscope:
5
      api-key: sk-441a047d9be542778a471a00ebbf9df8
6
      chat:
7
        options:
8
          model: qwen-max
9
      image:
10
        options:
11
          model: wanx2.1-t2i-plus
12
      audio:
13
        synthesis:
14
          options:
15
            model: cosyvoice-v1

3) 编写Controller


xxxxxxxxxx
122
1
/**
2
 * Sping AI 接入 阿里百炼 模型
3
 */
4
@RestController
5
@ConditionalOnProperty("spring.ai.dashscope.api-key")
6
@RequestMapping("/dashscope")
7
public class DashScopeClientModelController {
8

9
    /**
10
     * 阿里百炼 对话模型客户端
11
     */
12
    @Autowired
13
    private DashScopeChatModel dashScopeChatModel;
14

15
    /**
16
     * 阿里百炼 图片模型客户端
17
     */
18
    @Autowired
19
    private DashScopeImageModel dashScopeImageModel;
20

21
    /**
22
     * 阿里百炼 语音模型客户端
23
     */
24
    @Autowired
25
    private DashScopeSpeechSynthesisModel dashScopeSpeechSynthesisModel;
26

27
    /**
28
     * 接入阿里百炼对话模型 qwen-max
29
     *
30
     * @param msg
31
     * @return
32
     */
33
    @GetMapping("/chat")
34
    public String chat(@RequestParam(defaultValue = "你是谁？") String msg) {
35
        // 构建提示词
36
        Prompt prompt = new Prompt(msg, DashScopeChatOptions.builder()
37
                .withModel("qwen-max")
38
                .withTemperature(0.8)
39
                .build());
40

41
        // 对话
42
        ChatResponse chatResponse = dashScopeChatModel.call(prompt);
43
        return chatResponse.getResult().getOutput().getText();
44
    }
45

46
    /**
47
     * 接入阿里百炼流式对话模型 qwq-32b
48
     *
49
     * @param msg
50
     * @return
51
     */
52
    @GetMapping(value = "/stream", produces = "text/html;charset=UTF-8")
53
    public Flux<String> streamByQwq32b(@RequestParam(defaultValue = "你是谁？") String msg) {
54
        // 构建提示词
55
        Prompt prompt = new Prompt(msg, DashScopeChatOptions.builder()
56
                .withModel("qwq-32b")
57
                .withTemperature(0.8)
58
                .build());
59

60
        // 对话
61
        Flux<ChatResponse> chatResponseFlux = dashScopeChatModel.stream(prompt);
62
        return chatResponseFlux.map((r) -> r.getResult() != null && r.getResult().getOutput() != null && r.getResult().getOutput().getText() != null ? r.getResult().getOutput().getText() : "").filter(StringUtils::hasText);
63
    }
64

65
    /**
66
     * 接入阿里百炼文生图模型 wanx2.1-t2i-plus
67
     *
68
     * @param msg
69
     * @return
70
     */
71
    @GetMapping(value = "/image", produces = "text/html;charset=UTF-8")
72
    public void image(@RequestParam(defaultValue = "生成一个美女") String msg, HttpServletResponse httpServletResponse) throws IOException {
73
        // 构建图片提示词
74
        ImagePrompt imagePrompt = new ImagePrompt(msg,
75
                DashScopeImageOptions.builder()
76
                        .withModel(DashScopeImageApi.DEFAULT_IMAGE_MODEL)
77
                        .withN(1)//要生成的图像数。必须介于 1 和 10 之间。
78
                        .withHeight(1024)//生成的图像的高宽度。
79
                        .withWidth(1024).build());
80

81
        // 生成
82
        ImageResponse imageResponse = dashScopeImageModel.call(imagePrompt);
83
        String imageUrl = imageResponse.getResult().getOutput().getUrl();
84

85
        //输出到浏览器
86
        URL url = URI.create(imageUrl).toURL();
87
        InputStream in = url.openStream();
88
        httpServletResponse.setHeader("Content-Type", MediaType.IMAGE_PNG_VALUE);
89
        httpServletResponse.getOutputStream().write(in.readAllBytes());
90
        httpServletResponse.getOutputStream().flush();
91
    }
92

93
    /**
94
     * 接入阿里百炼文生语音模型 cosyvoice-v1
95
     *
96
     * @param msg
97
     * @return
98
     */
99
    @GetMapping(value = "/audio", produces = "text/html;charset=UTF-8")
100
    public String audio(@RequestParam(defaultValue = "床前明月光，疑是地上霜。举头望明月，低头思故乡。") String msg) throws IOException {
101
        // 构建语音提示词
102
        SpeechSynthesisPrompt speechSynthesisPrompt = new SpeechSynthesisPrompt(
103
                msg,
104
                DashScopeSpeechSynthesisOptions.builder()
105
                        .withSpeed(1.0) // 设置语速
106
                        .withPitch(0.9) // 设置音调
107
                        .withVolume(60) // 设置音量
108
                        .build());
109

110
        // 生成
111
        SpeechSynthesisResponse response = dashScopeSpeechSynthesisModel.call(speechSynthesisPrompt);
112

113
        // 输出到文件
114
        File file = new File("D:\\output.mp3");
115
        try (FileOutputStream fos = new FileOutputStream(file)) {
116
            ByteBuffer byteBuffer = response.getResult().getOutput().getAudio();
117
            fos.write(byteBuffer.array());
118
        }
119

120
        return "生成成功，请查看：" + file.getAbsolutePath();
121
    }
122
}

4. 接入Ollma本地模型

1) 部署本地模型

安装Ollma平台：访问官网https://ollama.com/ 下载对应系统的Ollma安装包进行安装，注意配置环境。
拉取AI模型：访问模型库https://ollama.com/library挑选所需的AI模型，通过ollama run deepseek-r1:1.5b命令拉取。
启动AI对话：模型安装成功后，可通过ollama run deepseek-r1:1.5b开启对话。

注意：
Ollma本地模型默认安装在C盘，可通过OLLAMA_MODELS环境变量进行修改。

2) 引入依赖


xxxxxxxxxx
6
1
<!-- Spring AI 集成 Ollma本地模型 -->
2
<dependency>
3
    <groupId>group.springframework.ai</groupId>
4
    <artifactId>spring-ai-ollama-spring-boot-starter</artifactId>
5
    <version>${spring-ai-ollma.version}</version>
6
</dependency>

3) 修改配置


xxxxxxxxxx
8
1
spring:
2
  ai:
3
    # Ollma本地模型
4
    ollama:
5
      base-url: http://localhost:11434
6
      chat:
7
        options:
8
          model: deepseek-r1:1.5b

4) 编写Controller


xxxxxxxxxx
29
1
/**
2
 * Sping AI 接入对话模型（定制客户端）
3
 */
4
@RestController
5
@RequestMapping("/ollma")
6
public class OllmaClientModelController {
7

8
    @Autowired
9
    private OllamaChatModel ollamaChatModel;
10

11
    /**
12
     * 接入Ollma本地对话模型 deepseek-r1:1.5b
13
     *
14
     * @param msg
15
     * @return
16
     */
17
    @GetMapping("/chat")
18
    public String chat(@RequestParam(defaultValue = "你是谁？") String msg) {
19
        // 构建提示词
20
        OllamaOptions ollamaOptions = OllamaOptions.create();
21
        ollamaOptions.withModel("deepseek-r1:1.5b").withTemperature(0.8F);
22
        Prompt prompt = new Prompt(msg, ollamaOptions);
23

24
        // 对话
25
        ChatResponse chatResponse = ollamaChatModel.call(prompt);
26
        return chatResponse.getResult().getOutput().getContent();
27
    }
28

29
}

5. ChatClient工具

1) 什么是ChatClient？

ChatModel是 Spring AI 与 AI 模型交互的基础接口，直接和具体的 AI 模型（如OpenAI、DeepSeek、通义千问等）进行交互。

ChatClient是对 ChatModel 的进一步封装，它屏蔽了底层模型的差异性，为开发者提供了统一的接口来和不同的 AI 模型进行交互。

2) 配置ChatClient


xxxxxxxxxx
95
1
/**
2
 * AI 相关配置
3
 */
4
@Configuration
5
public class AiConfig {
6

7
    /**
8
     * 对话记忆存储器（用于存储历史对话记录，实现对话连续性）
9
     */
10
    @Bean
11
    public ChatMemory chatMemory() {
12
        return new InMemoryChatMemory();
13
    }
14

15
    /**
16
     * 向量数据库
17
     *
18
     * @param embeddingModel 向量模型（通过yml配置自动创建和注入）
19
     * @return 向量数据库
20
     */
21
    @Bean
22
    VectorStore vectorStore(DashScopeEmbeddingModel embeddingModel) {
23
        return SimpleVectorStore.builder(embeddingModel).build();
24
    }
25

26
    /**
27
     * 通用对话客户端（支持多种AI模型的基础功能）
28
     *
29
     * @param chatClientBuilder
30
     * @return
31
     */
32
    @Bean
33
    public ChatClient chatClient(ChatClient.Builder chatClientBuilder, ChatMemory chatMemory, VectorStore vectorStore) {
34
        return chatClientBuilder
35
                .defaultSystem("请以中文友好回答。") // 默认角色预设
36
                .defaultAdvisors(new MessageChatMemoryAdvisor(chatMemory)) // 对话记忆存储
37
                .defaultAdvisors(new QuestionAnswerAdvisor(vectorStore)) // 向量数据库
38
                .defaultTools("addOperation", "mulOperation") // AI工具函数
39
                .build();
40
    }
41
}
42

43
/**
44
 * AI工具函数配置
45
 */
46
@Configuration
47
@Slf4j
48
public class ToolsConfig {
49
    /**
50
     * 加法函数输入
51
     *
52
     * @param a
53
     * @param b
54
     */
55
    public record AddOperation(int a, int b) {
56
    }
57

58
    /**
59
     * 乘法函数输入
60
     *
61
     * @param m
62
     * @param n
63
     */
64
    public record MulOperation(int m, int n) {
65
    }
66

67
    /**
68
     * 加法函数
69
     *
70
     * @return 匿名内部类对象
71
     */
72
    @Bean
73
    @Description("加法运算")
74
    public Function<AddOperation, Integer> addOperation() {
75
        return request -> {
76
            log.info("加法函数被调用，参数为：{}", request);
77
            return request.a + request.b;
78
        };
79
    }
80

81
    /**
82
     * 乘法函数
83
     *
84
     * @return 匿名内部类对象
85
     */
86
    @Bean
87
    @Description("乘法运算")
88
    public Function<MulOperation, Integer> mulOperation() {
89
        return request -> {
90
            log.info("乘法函数被调用，参数为：{}", request);
91
            return request.m * request.n;
92
        };
93
    }
94
}
95

3) 使用ChatClient


xxxxxxxxxx
51
1
/**
2
 * Sping AI 接入对话模型（通用客户端）
3
 */
4
@RestController
5
@RequestMapping("/chatclient")
6
public class ChatClientController {
7

8
    /**
9
     * 对话模型通用客户端（也支持流式对话）
10
     */
11
    @Autowired
12
    private ChatClient chatClient;
13

14
    /**
15
     * 接入阿里百炼对话模型 qwen-max（注意修改yml文件中的模型配置）
16
     *
17
     * @param msg
18
     * @return
19
     */
20
    @GetMapping("/chat")
21
    public String chat(@RequestParam(name = "sessionId", defaultValue = "1") Integer sessionId, @RequestParam(defaultValue = "你是谁？") String msg) {
22
        return chatClient.prompt()
23
                .system("您是一个航天助手，正在通过在线聊天和客户进行互动，请以友好的中文进行回复。") // 个性化角色预设
24
                .user(msg)  // 用户消息
25
                .advisors(spec -> spec
26
                        .param(AbstractChatMemoryAdvisor.CHAT_MEMORY_CONVERSATION_ID_KEY, sessionId)
27
                        .param(AbstractChatMemoryAdvisor.CHAT_MEMORY_RETRIEVE_SIZE_KEY, 100)
28
                )
29
                .call()// 对话
30
                .content();
31
    }
32

33
    /**
34
     * 接入阿里百炼对话模型 qwq-32b（注意修改yml文件中的模型配置）
35
     *
36
     * @param msg
37
     * @return
38
     */
39
    @GetMapping(value = "/stream", produces = "text/html;charset=UTF-8")
40
    public Flux<String> stream(@RequestParam(name = "sessionId", defaultValue = "1") Integer sessionId, @RequestParam(defaultValue = "你是谁？") String msg) {
41
        return chatClient.prompt()
42
                .system("你是KD公司的智能风控小助手。") // 个性化角色预设
43
                .user(msg)  // 用户消息
44
                .advisors(spec -> spec
45
                        .param(AbstractChatMemoryAdvisor.CHAT_MEMORY_CONVERSATION_ID_KEY, sessionId)
46
                        .param(AbstractChatMemoryAdvisor.CHAT_MEMORY_RETRIEVE_SIZE_KEY, 100)
47
                )
48
                .stream()// 流式对话
49
                .content();
50
    }
51
}

6. 检索增强生成(RAG)

1) 什么是RAG？

RAG（Retrieval-Augmented Generation ）指检索增强生成式人工智能，是一种将大型语言模型（LLM）与外部知识源相结合的人工智能技术。通过在生成响应前检索相关信息，RAG 能够为模型提供最新且特定领域的知识，从而提高回答的准确性和相关性。

2) 对数据进行向量化

步骤：文档 → 解析 → chunks → Embedding → 向量 → 存入向量库，最终结果形成知识库，整个过程叫 indexing。


xxxxxxxxxx
76
1
/**
2
 * 检索增强生成(RAG)
3
 */
4
@RestController
5
@RequestMapping("/embedding")
6
public class EmbeddingController {
7

8
    /**
9
     * 千问向量模型（SpringBoot根据yml中的配置自动创建）
10
     */
11
    @Autowired
12
    private DashScopeEmbeddingModel embeddingModel;
13

14
    /**
15
     * 向量数据库（AiConfig中配置了一个内存向量数据，用于存储向量化后的私有知识，实现检索增强生成(RAG)）
16
     */
17
    @Autowired
18
    private VectorStore vectorStore;
19

20
    /**
21
     * 向量化文本
22
     *
23
     * @param msg 文本
24
     */
25
    @RequestMapping("/embed")
26
    public void embed(@RequestParam(defaultValue = "我是黄原鑫") String msg) {
27
        // 存储
28
        List<Document> documents = List.of(new Document(msg));
29
        System.out.println(documents);
30
        vectorStore.add(documents);
31
    }
32

33
    /**
34
     * 向量化文件
35
     */
36
    @RequestMapping("/embedFile")
37
    public void embedFile() throws IOException {
38
        // 加载文件
39
        Resource resource = new ClassPathResource("rag/机票预订须知.txt");
40

41
        // 分割
42
        TikaDocumentReader tikaDocumentReader = new TikaDocumentReader(resource);
43
        List<Document> splitDocuments = new TokenTextSplitter().apply(tikaDocumentReader.read());
44
        System.out.println(splitDocuments);
45

46
        // 存储
47
        vectorStore.add(splitDocuments);
48

49
    }
50

51

52
    /**
53
     * 向量化查询
54
     *
55
     * @param msg 文本
56
     */
57
    @RequestMapping("/query")
58
    public String query(@RequestParam(defaultValue = "我是谁？") String msg) {
59

60
        // 构建向量查询请求
61
        SearchRequest request = SearchRequest.builder()
62
                .query(msg)
63
                .topK(3)
64
                .build();
65

66
        // 向量查询
67
        List<Document> result = vectorStore.similaritySearch(request);
68
        if (result == null || result.isEmpty()) {
69
            return "";
70
        }
71

72
        // 输出
73
        System.out.println(result);
74
        return result.toString();
75
    }
76
}

3) 增强生成内容

一个 RAG 系统的数据流程如下：

离线预处理（Indexing）：先把原始文档解析、清洗，切分成短文本块；再用 Embedding 模型把文本块转成语义向量，最后存入向量数据库，完成知识库构建。
在线查询：用户提问后，用同一 Embedding 模型把问题转成向量，在向量库中检索出语义最相关的文档。
生成回答：把用户问题 + 检索到的上下文拼成 Prompt，输入大模型，生成有事实依据、无幻觉的最终回答。

代码请参考前一小节示例。

第二节 Spring AI Alibaba

1. Spring AI Alibaba 简介

1) 什么是Spring AI Alibaba？

Spring AI Alibaba 是阿里云基于官方 Spring AI 构建、专为 Java 开发者设计的开源企业级 AI 应用与 AI Agent 开发框架。

官网地址：https://java2ai.com/
阿里百炼：https://bailian.console.aliyun.com/
版本推荐：https://java2ai.com/docs/versions

项目架构分为三层：

Agent Framework：基于 ReactAgent 理念构建支持自动上下文工程与人机交互的 Agent 。
Graph：底层工作流与多代理协调框架，提供预置节点和简化的状态管理，作为 Agent Framework 的运行时基座。
Augmented LLM：基于 Spring AI 的原子抽象，提供模型、工具、MCP、消息、向量存储等 LLM 应用基础能力。

2) 主流 Java AI 框架选型

以下是当前主流 Java AI 框架对比情况：

对比维度	Spring AI Alibaba	Spring AI	LangChain4J
Spring Boot 集成	原生支持	原生支持	社区适配
文本模型	主流模型，可扩展	主流模型，可扩展	主流模型，可扩展
音视频、多模态、向量模型	支持	支持	支持
RAG	模块化 RAG	模块化 RAG	模块化 RAG
向量数据库	主流向量数据库阿里云ADB、OpenSearch等	主流向量数据库	主流向量数据库
MCP 支持	支持 Nacos MCP Registry 支持	支持	支持
函数调用	支持（20+官方工具集成）	支持	支持
提示词模版	硬编码，无声明式注解	硬编码，无声明式注解	声明式注解
提示词管理	Nacos 配置中心	无	无
Chat Memory	优化版JDBC、Redis、ElasticSearch	JDBC、Neo4j、Cassandra	多种实现适配
可观测性	支持，可接入阿里云ARMS	支持	部分支持
工作流 Workflow	支持，兼容 Dify、百炼 DSL	无	无
多智能体 Multi-agent	支持，官方通用智能体实现	无	无
模型评测	支持	支持	支持
社区活跃度与文档健全性	官方社区，活跃度高	官方社区，活跃度高	个人发起社区
开发提效组件	丰富，包括调试、代码生成工具等	无	无
Example 仓库	丰富，活跃度高	较少	丰富，活跃度高

Spring AI Alibaba不仅可以通过 Nacos 配置中心管理提示词，还在可观测性、工作流、多智能体方面做的更好。

2. 入门案例

1) 导入依赖

父工程：


xxxxxxxxxx
48
1
<?xml version="1.0" encoding="UTF-8"?>
2
<project xmlns="http://maven.apache.org/POM/4.0.0"
3
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5
    <modelVersion>4.0.0</modelVersion>
6

7
    <groupId>com.huangyuanxin.ai</groupId>
8
    <artifactId>SpringAI-Alibaba-demo</artifactId>
9
    <version>1.0-SNAPSHOT</version>
10
    <packaging>pom</packaging>
11
    <modules>
12
        <module>SpringAI-Alibaba-demo01</module>
13
    </modules>
14

15
    <!-- 必须基于 JDK 17+ 构建 -->
16
    <properties>
17
        <maven.compiler.source>17</maven.compiler.source>
18
        <maven.compiler.target>17</maven.compiler.target>
19
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
20
    </properties>
21

22
    <!-- 依赖管理 -->
23
    <dependencyManagement>
24
        <dependencies>
25
            <dependency>
26
                <groupId>com.alibaba.cloud.ai</groupId>
27
                <artifactId>spring-ai-alibaba-bom</artifactId>
28
                <version>1.1.2.0</version>
29
                <type>pom</type>
30
                <scope>import</scope>
31
            </dependency>
32
            <dependency>
33
                <groupId>org.springframework.ai</groupId>
34
                <artifactId>spring-ai-bom</artifactId>
35
                <version>1.1.2</version>
36
                <type>pom</type>
37
                <scope>import</scope>
38
            </dependency>
39
            <dependency>
40
                <groupId>com.alibaba.cloud.ai</groupId>
41
                <artifactId>spring-ai-alibaba-extensions-bom</artifactId>
42
                <version>1.1.2.1</version>
43
                <type>pom</type>
44
                <scope>import</scope>
45
            </dependency>
46
        </dependencies>
47
    </dependencyManagement>
48
</project>

子工程：


xxxxxxxxxx
33
1
<?xml version="1.0" encoding="UTF-8"?>
2
<project xmlns="http://maven.apache.org/POM/4.0.0"
3
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
4
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5
    <modelVersion>4.0.0</modelVersion>
6
    <parent>
7
        <groupId>com.huangyuanxin.ai</groupId>
8
        <artifactId>SpringAI-Alibaba-demo</artifactId>
9
        <version>1.0-SNAPSHOT</version>
10
    </parent>
11

12
    <artifactId>SpringAI-Alibaba-demo01</artifactId>
13

14
    <properties>
15
        <maven.compiler.source>23</maven.compiler.source>
16
        <maven.compiler.target>23</maven.compiler.target>
17
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
18
    </properties>
19

20
    <dependencies>
21
        <dependency>
22
            <groupId>com.alibaba.cloud.ai</groupId>
23
            <artifactId>spring-ai-alibaba-agent-framework</artifactId>
24
        </dependency>
25

26
        <dependency>
27
            <groupId>com.alibaba.cloud.ai</groupId>
28
            <artifactId>spring-ai-alibaba-starter-dashscope</artifactId>
29
        </dependency>
30

31
    </dependencies>
32

33
</project>

2) Agent示例


xxxxxxxxxx
23
1
public class AgentExample {
2

3
    public static void main(String[] args) throws Exception {
4
        // 创建模型实例
5
        DashScopeApi dashScopeApi = DashScopeApi.builder()
6
                .apiKey("sk-441a047d9be542778a471a00ebbf9df1") // 生产环境通过系统环境变量获取
7
                .build();
8
        ChatModel chatModel = DashScopeChatModel.builder()
9
                .dashScopeApi(dashScopeApi)
10
                .build();
11

12
        // 创建 Agent
13
        ReactAgent agent = ReactAgent.builder()
14
                .name("智能问答助手")
15
                .model(chatModel)
16
                .instruction("你是一个智能问答助手，可以回答用户的任何问题")
17
                .build();
18

19
        // 运行 Agent
20
        AssistantMessage response = agent.call("你好！你是谁？");
21
        System.out.println(response.getText()); // 你好！😊 我是通义千问（Qwen）......
22
    }
23
}

第三节 LangChain4J

1. 基本使用

1) 导入依赖


xxxxxxxxxx
43
1
<dependencies>
2
    <!-- LangChain4j核心 -->
3
    <dependency>
4
        <groupId>dev.langchain4j</groupId>
5
        <artifactId>langchain4j</artifactId>
6
        <version>1.0.1</version>
7
    </dependency>
8
    <!-- LangChain4j的MCPClient -->
9
    <dependency>
10
        <groupId>dev.langchain4j</groupId>
11
        <artifactId>langchain4j-mcp</artifactId>
12
        <version>1.0.1-beta6</version>
13
    </dependency>
14

15
    <!-- OpenAI/DeepSeek -->
16
    <dependency>
17
        <groupId>dev.langchain4j</groupId>
18
        <artifactId>langchain4j-open-ai</artifactId>
19
        <version>1.0.1</version>
20
    </dependency>
21

22
    <!-- 阿里百炼 -->
23
    <dependency>
24
        <groupId>dev.langchain4j</groupId>
25
        <artifactId>langchain4j-community-dashscope</artifactId>
26
        <version>1.0.1-beta6</version>
27
    </dependency>
28

29
    <!-- Ollama本地模型 -->
30
    <dependency>
31
        <groupId>dev.langchain4j</groupId>
32
        <artifactId>langchain4j-ollama</artifactId>
33
        <version>1.0.1-beta6</version>
34
    </dependency>
35

36
    <!-- 单元测试 -->
37
    <dependency>
38
        <groupId>org.junit.jupiter</groupId>
39
        <artifactId>junit-jupiter</artifactId>
40
        <version>5.8.2</version>
41
        <scope>test</scope>
42
    </dependency>
43
</dependencies>

2) 接入对话模型


xxxxxxxxxx
57
1
/**
2
 * 一、LangChain4J接入常见对话模型
3
 *
4
 * @author HuangYuanXin
5
 * @date 2025/06/18 05:46
6
 **/
7
public class Test01_LangChain4J {
8

9
    /**
10
     * 1. 接入DeepSeek官方的 deepseek-chat 模型
11
     */
12
    @Test
13
    public void deepseekChat() {
14
        // 构建模型
15
        OpenAiChatModel model = OpenAiChatModel.builder()
16
                .baseUrl("https://api.deepseek.com")
17
                .apiKey("sk-04b52cab40d7443486c24a7a09691ec9")
18
                .modelName("deepseek-chat").build();
19

20
        // 对话
21
        String answer = model.chat("你好，你是谁？");
22
        System.out.println(answer);
23
    }
24

25
    /**
26
     * 2. 接入阿里百炼的 qwen-max 模型
27
     */
28
    @Test
29
    public void qwenMax() {
30
        // 构建模型
31
        QwenChatModel model = QwenChatModel.builder()
32
                .apiKey("sk-441a047d9be542778a471a00ebbf9df8")
33
                .modelName("qwen-max")
34
                .build();
35

36
        // 对话
37
        String answer = model.chat("你好，你是谁？");
38
        System.out.println(answer);
39
    }
40

41
    /**
42
     * 3. 接入Ollama本地的 deepseek-r1:1.5b 模型
43
     */
44
    @Test
45
    public void OllamaChat() {
46
        // 构建模型
47
        OllamaChatModel model = OllamaChatModel.builder()
48
                .baseUrl("http://localhost:11434") // Ollama默认端口为11434
49
                .modelName("deepseek-r1:1.5b")
50
                .build();
51

52
        // 对话
53
        String answer = model.chat("你好，你是谁？");
54
        System.out.println(answer);
55
    }
56

57
}

3) 接入图片/语音模型


xxxxxxxxxx
45
1
/**
2
 * 二、LangChain4J接入图片/语音模型
3
 */
4
public class Test02_ImageAudition {
5
    /**
6
     * 1. 接入阿里炼的文生图模型：万相
7
     */
8
    @Test
9
    public void generateImage() {
10
        // 构建文生图模型
11
        WanxImageModel model = WanxImageModel.builder()
12
                .modelName("wanx2.1-t2i-plus")
13
                .apiKey("sk-441a047d9be542778a471a00ebbf9df8")
14
                .build();
15

16
        // 生成图片
17
        Response<Image> response = model.generate("美女");
18
        System.out.println(response.content().url());
19
    }
20

21
    /**
22
     * 2. 接入阿里百炼的文生语音模型：cosyvoice-v1
23
     */
24
    @Test
25
    public void generateAudition() {
26
        // 调用参数
27
        SpeechSynthesisParam param = SpeechSynthesisParam.builder()
28
                .apiKey("sk-441a047d9be542778a471a00ebbf9df8")
29
                .model("cosyvoice-v1")
30
                .text("大家好，我是黄原鑫")
31
                .build();
32

33
        // 调用模型
34
        SpeechSynthesizer speechSynthesizer = new SpeechSynthesizer();
35
        ByteBuffer audio = speechSynthesizer.call(param);
36

37
        // 输出到文件
38
        File file = new File("D:\\output.mp3");
39
        try (FileOutputStream fos = new FileOutputStream(file)) {
40
            fos.write(audio.array());
41
        } catch (IOException e) {
42
            throw new RuntimeException(e);
43
        }
44
    }
45
}

4) 实现智能体(AI Agent)


xxxxxxxxxx
104
1
/**
2
 * 三、基于LangChain4J实现智能体（多个AI模型编排）
3
 *
4
 * @author HuangYuanXin
5
 * @date 2025/06/18 05:46
6
 **/
7
@Slf4j
8
public class Test03_IntelligentAgent {
9

10
    /**
11
     * 业务类型枚举
12
     */
13
    public enum BizType {
14
        @Description("查询图书信息")
15
        QUERY_BOOK,
16
        @Description("上架图书")
17
        ADD_BOOK,
18
        @Description("其它业务")
19
        OTHER
20
    }
21

22
    /**
23
     * 业务类型识别器
24
     */
25
    interface BizTypeRecognizer {
26
        @UserMessage("以下文本是什么业务类型：{{it}}")
27
        BizType identify(String msg);
28
    }
29

30
    /**
31
     * 聊天机器人
32
     */
33
    interface ChatBot {
34
        @SystemMessage("""
35
                你是图书管理系统的管理员，请为客户服务。
36
                """)
37
        String reply(String msg);
38
    }
39

40
    /**
41
     * 业务处理器
42
     */
43
    class BizHandler {
44
        private BizTypeRecognizer bizTypeRecognizer;
45
        private ChatBot chatBot;
46

47
        public BizHandler(BizTypeRecognizer bizTypeRecognizer, ChatBot chatBot) {
48
            this.bizTypeRecognizer = bizTypeRecognizer;
49
            this.chatBot = chatBot;
50
        }
51

52
        /**
53
         * 处理业务
54
         *
55
         * @param msg
56
         * @return
57
         */
58
        public String handle(String msg) {
59
            // 识别业务类型
60
            BizType bizType = bizTypeRecognizer.identify(msg);
61

62
            // 根据业务类型处理业务
63
            switch (bizType) {
64
                case QUERY_BOOK:
65
                    log.info("queryBook: {}", msg);
66
                    return "查询图书成功，只有1本《格列夫游记》"; // 已知业务调用对应API接口
67
                case ADD_BOOK:
68
                    log.info("addBook: {}", msg);
69
                    return "添加图书成功"; // 已知业务调用对应API接口
70
                case OTHER:
71
                    log.info("other: {}", msg);
72
                    return chatBot.reply(msg); // 其它类型任务交给智能助手处理
73
                default:
74
                    log.info("unknown biz type");
75
                    return "业务类型识别错误";
76
            }
77
        }
78
    }
79

80
    /**
81
     * 使用AI模型+业务接口处理业务
82
     */
83
    @Test
84
    public void test() {
85
        // 创建多个AI对话模型
86
        OpenAiChatModel deepseekChatModel = OpenAiChatModel.builder()
87
                .baseUrl("https://api.deepseek.com")
88
                .apiKey("sk-04b52cab40d7443486c24a7a09691ec9")
89
                .modelName("deepseek-chat").build();
90
        QwenChatModel qwenChatModel = QwenChatModel.builder()
91
                .apiKey("sk-441a047d9be542778a471a00ebbf9df8")
92
                .modelName("qwen-max")
93
                .build();
94

95
        // 使用AI模型+业务接口创建业务对象
96
        BizTypeRecognizer bizTypeRecognizer = AiServices.create(BizTypeRecognizer.class, deepseekChatModel);
97
        ChatBot chatBot = AiServices.create(ChatBot.class, qwenChatModel);
98

99
        // 使用AI业务对象处理业务
100
        BizHandler bizHandler = new BizHandler(bizTypeRecognizer, chatBot);
101
        String rssult = bizHandler.handle("帮我查询一共有多少图书？");
102
        System.out.println(rssult);
103
    }
104
}

5) 调用MCP服务


xxxxxxxxxx
16
1
/**
2
 * 通过LangChain4J调用MCP服务（MCP是一种AI工具服务调用协议）
3
 *
4
 * @author HuangYuanXin
5
 * @date 2025/06/18 05:46
6
 **/
7
@Slf4j
8
public class Test03_MCPClient {
9

10
    // 测试npx方式调用百度地图MCP
11
    @Test
12
    public void test() {
13
        // TODO
14
    }
15

16
}

2. 整合SpringBoot

1) 引入依赖


xxxxxxxxxx
34
1
<dependencies>
2
    <!-- LangChain4j框架 -->
3
    <dependency>
4
        <groupId>dev.langchain4j</groupId>
5
        <artifactId>langchain4j</artifactId>
6
        <version>1.0.1</version>
7
    </dependency>
8

9
    <!-- WEB启动器 -->
10
    <dependency>
11
        <groupId>org.springframework.boot</groupId>
12
        <artifactId>spring-boot-starter-web</artifactId>
13
    </dependency>
14

15
    <!-- WEBFLUX启动器 -->
16
    <dependency>
17
        <groupId>org.springframework.boot</groupId>
18
        <artifactId>spring-boot-starter-webflux</artifactId>
19
    </dependency>
20

21
    <!-- OpenAi/DeepSeek启动器 -->
22
    <dependency>
23
        <groupId>dev.langchain4j</groupId>
24
        <artifactId>langchain4j-open-ai-spring-boot-starter</artifactId>
25
        <version>1.0.1-beta6</version>
26
    </dependency>
27

28
    <!-- 阿里百炼启动器 -->
29
    <dependency>
30
        <groupId>dev.langchain4j</groupId>
31
        <artifactId>langchain4j-community-dashscope-spring-boot-starter</artifactId>
32
        <version>1.0.1-beta6</version>
33
    </dependency>
34
</dependencies>

2) 模型配置


xxxxxxxxxx
24
1
server:
2
  port: 8080
3

4
langchain4j:
5
  # OpenAi/Deepseek
6
  open-ai:
7
    chat-model:
8
      base-url: https://api.deepseek.com
9
      api-key: sk-04b52cab40d7443486c24a7a09691ec9
10
      model-name: deepseek-chat
11
  # 阿里百炼
12
  community:
13
    dashscope:
14
      # 对话模型
15
      chat-model:
16
        api-key: sk-441a047d9be542778a471a00ebbf9df8
17
        model-name: qwen-max
18
      # 流式对话模型
19
      streaming-chat-model:
20
        api-key: sk-441a047d9be542778a471a00ebbf9df8
21
        model-name: qwq-32b
22
      # 向量模型
23
      embedding-model:
24
        api-key: sk-441a047d9be542778a471a00ebbf9df8

3) 创建代理


xxxxxxxxxx
94
1
/**
2
 * AI相关配置
3
 */
4
@Configuration
5
public class AiConfig {
6

7
    /**
8
     * AI工具服务（用于function-call调用）
9
     */
10
    @Autowired
11
    private AiToolsService aiToolsService;
12

13
    /**
14
     * 对话记忆存储器（用于存储历史对话记录，实现对话连续性）
15
     */
16
    @Autowired
17
    private RedisMemoryStore redisMemoryStore;
18

19
    /**
20
     * 向量数据库（用于存储向量化后的私有知识，实现检索增强生成(RAG)，常见向量数据库有：内存向量数据库、Redis向量数据库、Elasticsearch向量数据库等）
21
     *
22
     * @return
23
     */
24
    @Bean
25
    public EmbeddingStore<TextSegment> embeddingStore() {
26
        return new InMemoryEmbeddingStore<>(); // 内存向量数据库
27
    }
28

29
    /**
30
     * AI模型代理接口（LangChain4J会根据接口生成代理对象，并根据构建参数实现附加功能）
31
     */
32
    public interface AiModelProxy {
33
        /**
34
         * 对话
35
         *
36
         * @param memoryId 记忆ID 一般是会话ID或用户ID
37
         * @param msg      用户消息
38
         * @return 对话应答
39
         */
40
        @SystemMessage("""
41
                您是一个航天助手，正在通过在线聊天和客户进行互动，请以友好的中文进行回复。
42
                """)
43
        String chat(@MemoryId int memoryId, @UserMessage String msg);
44

45
        /**
46
         * 对话（流式）
47
         *
48
         * @param memoryId 记忆ID 一般是会话ID或用户ID
49
         * @param msg      用户消息
50
         * @param bizdate  业务日期（通过系统消息预设角色时所用的参数）
51
         * @return 对话应答（流式）
52
         */
53
        @SystemMessage("""
54
                您是KD公司的交易实时风控系统，正在通过在线聊天和客户进行互动，请以友好的中文进行回复。
55
                您可以为客户查询指标的阈值、设置指标的阈值，以及删除指标等操作。
56
                今天的业务日期是{{bizdate}}
57
                """)
58
        TokenStream stream(@MemoryId int memoryId, @UserMessage String msg, @V("bizdate") Integer bizdate);
59
    }
60

61
    /**
62
     * AI模型代理（调用AI模型对话，并添加了一些额外功能）
63
     *
64
     * @param qwenChatModel          AI对话模型
65
     * @param qwenStreamingChatModel AI流式对话模型
66
     * @param qwenEmbeddingModel     AI向量模型
67
     * @param embeddingStore         向量数据库
68
     * @return AI模型代理对象
69
     */
70
    @Bean
71
    public AiModelProxy qwenAiModelProxy(QwenChatModel qwenChatModel, QwenStreamingChatModel qwenStreamingChatModel, QwenEmbeddingModel qwenEmbeddingModel, EmbeddingStore<TextSegment> embeddingStore) {
72

73
        // 构建内容检索器（用于检索向量数据库，实现检索增强生成(RAG)）
74
        EmbeddingStoreContentRetriever contentRetriever = EmbeddingStoreContentRetriever.builder()
75
                .embeddingStore(embeddingStore) // 从哪个向量数据库检索
76
                .embeddingModel(qwenEmbeddingModel) // 检索时使用的AI向量模型
77
                .maxResults(5) // 最大结果数
78
                .minScore(0.5) // 最小匹配分数
79
                .build();
80

81
        // 创建Ai模型代理
82
        AiModelProxy qwenAiModelProxy = AiServices.builder(AiModelProxy.class)
83
                .chatModel(qwenChatModel) // AI对话模型
84
                .streamingChatModel(qwenStreamingChatModel) // AI流式对话模型
85
                .chatMemoryProvider(memoryId -> MessageWindowChatMemory.builder().maxMessages(10).id(memoryId).build()) // 对话记忆存储器
86
                //.chatMemoryProvider(memoryId -> MessageWindowChatMemory.builder().maxMessages(10).id(memoryId).chatMemoryStore(redisMemoryStore).build()) // 使用自定义的对话记忆存储器
87
                .tools(aiToolsService) // AI工具服务（用于function-call调用）
88
                .contentRetriever(contentRetriever) // 内容检索器（用于检索向量数据库，实现检索增强生成(RAG)）
89
                .build();
90

91
        return qwenAiModelProxy;
92
    }
93

94
}

4) 流式对话


xxxxxxxxxx
35
1
/**
2
 * LangChain4J接入常见AI流式对话模型（SpringBoot版）
3
 */
4
@RestController
5
@RequestMapping("/stream")
6
public class StreamController {
7

8
    /**
9
     * 使用AI模型代理流式对话（附加：预设角色、对话记忆存储、AI工具服务、检索增强生成）
10
     *
11
     * @param msg
12
     * @return
13
     */
14
    @Autowired
15
    private AiConfig.AiModelProxy qwenAiModelProxy;
16

17
    /**
18
     * 使用AI模型代理流式对话（附加：预设角色、对话记忆存储、AI工具服务、检索增强生成）
19
     *
20
     * @param msg
21
     * @return
22
     */
23
    @RequestMapping(value = "/qwenAiModelProxy", produces = "text/stream;charset=UTF-8")
24
    public Flux<String> chatByQwenAiModelProxy(@RequestParam(name = "sessionId", defaultValue = "1") Integer sessionId, @RequestParam(defaultValue = "你是谁？") String msg) {
25
        TokenStream tokenStream = qwenAiModelProxy.stream(sessionId, msg, Integer.valueOf(LocalDate.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"))));
26

27
        return Flux.create(sink -> {
28
            tokenStream.onPartialResponse(s -> sink.next(s))
29
                    .onCompleteResponse(c -> sink.complete())
30
                    .onError(sink::error)
31
                    .start();
32
        });
33
    }
34

35
}

AI入门课

第01章_AI快速入门

第一节 基础概念

1. AI简介

1) 什么是AI？

2) AI的发展简史

3) AI的发展现状

2. 相关名词

1) 大模型/Token

2) Agent/Claw/Swarm

3) MCP/Skill/Plugin

4) FunctionCall/Embedding/RAG

5) 其它补充

3. 模型交互

1) Prompt Engine

2) Context Engine

3) Harness Engine

4. 向量化

第二节 理论基础

1. 理论基础01

1) 什么是深度学习？

2) 深度学习与机器学习的区别?

3) 神经网络结构

4) 学习方式有哪些？

5) 什么是过拟合和欠拟合？

6) 什么是注意力机制？

第三节 大模型

1. 大模型部署

1) 基于Ollma部署大模型

2) 基于vLLM部署大模型

2. 大模型微调

3. 大模型训练

第02章_AI工具使用

第一节 Claude Code

1. 安装部署

1) 什么是Claude Code？

2) 命令行安装

3) 插件安装

2. 基本使用

1) 基本命令

2) 会话管理

3) 文件 / 项目操作

3) 高级扩展

4) Skill示例

3. 其它AI编程工具

1) Cursor

2) Trce

3) Open Code

4) Codex

5) Qorder

第二节 OpenClaw

1. 安装部署

1) 什么是OpenClaw？

2) Windows安装

3) Linux安装

2. 基本使用

1) 常用命令

2) 修改大模型

3) 配置渠道

4) 添加SKILL

第三节 DALL.E3

第四节 Midjourney

第五节 Dify

第六节 milvus

1. 安装部署

1) 什么是milvus？

2) 安装milvus

2. 基本使用

1) 导入依赖

2) 创建Collection和Schema

3) 数据增删查

3. 其它向量数据库

1) Redis Stack

第03章_AI应用开发

第一节 SpringAI

1. SpringAI简介

1) 什么是Spring AI？

2. 接入DeepSeek

1) 引入依赖

2) 创建配置文件

第一节基础概念

第二节理论基础

第三节大模型