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

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

• 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分步推理）；
• 避免提示词过于简略、未限定输出格式、未明确核心需求。

注意：

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

2) Context Engine

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

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

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

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

注意：

1. 上下文越长，推理延迟和 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

注意：

1. 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

xxxxxxxxxx
36
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分页注意力技术为核心，极致优化显存与并发，是当前生产环境部署大模型的主流首选。

​x
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

注意：

1. 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应用开发(Java)

第一节 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
}