来源： Visual Studio 修改NuGet 包缓存路径 – Earen – 博客园

Visual Studio 下载的NuGet包默认会缓存到 C:\Users{Windows用户名}.nuget\packages 下，时间一长就会导致 C盘空间严重不足。

那么怎样去设置，让包缓存文件保存到其他盘呢？

首先我们要找到 Microsoft.VisualStudio.Offline.config 这个文件，它在哪呢？ 在 C:\Program Files (x86)\NuGet\Config。

再到文件并用记事本打开 如下：

我们在中间增加如下配置内容：

  <config>
      <add key="globalPackagesFolder" value="D:\Nuget\.nuget\packages" />
  </config>

最终效果如下图：

这样就配置好了，重新打开 Visual Studio 下载 NuGet 包文件后，查看包的引用地址就会发现地址为修改后的地址。

温馨提示：在配置好地址后，可将原来已经缓存的包文件全部拷贝到新的目录中。

来源： Spring AI与DeepSeek实战四：系统API调用 – zlt2000 – 博客园

一、概述

在 AI 应用开发中，工具调用 Tool Calling 是增强大模型能力的核心技术。通过让模型与外部 API 或工具交互，可实现 实时信息检索（如天气查询、新闻获取）、系统操作（如创建任务、发送邮件）等功能。

Spring AI 作为企业级 AI 开发框架，在 1.0.0.M6 版本中进行了重要升级：废弃 Function Calling 引入 Tool Calling 以更贴合行业术语；本文结合 Spring AI 与大模型，演示如何通过 Tool Calling 实现系统 API 调用，同时处理多轮对话中的会话记忆。

关于 Spring AI 与 DeepSeek 的集成，以及 API-KEY 的申请等内容，可参考文章《Spring AI与DeepSeek实战一：快速打造智能对话应用》

二、函数调用原理

大模型仅负责 决定是否调用工具 和 提供参数，实际执行逻辑由客户端（Spring 应用）实现，确保工具调用的可控性与安全性。

2.1. 工具元数据注入

在发起Chat Request时，将工具描述（name/description）、参数结构（input schema）等元数据封装至请求体，建立大模型的工具调用能力基线。

2.2. 模型决策响应

大模型根据上下文推理生成工具调用指令（tool_calls字段），返回包含选定工具名称及结构化参数的中间响应。

2.3. 服务端路由执行

Spring AI模块解析工具调用指令，通过服务发现机制定位目标工具实例，注入参数并触发同步/异步执行。

2.4. 执行结果标准化

工具返回原始执行结果后，系统进行数据类型校验、异常捕获和JSON序列化处理，生成模型可解析的标准化数据结构。

2.5. 上下文增强推理

将标准化结果作为新增上下文（tool_outputs）回传大模型，触发基于增强上下文的二次推理流程。

2.6. 终端响应生成

模型综合初始请求与工具执行结果，生成最终自然语言响应，完成工具增强的对话闭环。

三、核心代码

3.1. 定义工具

创建类 TestTools 并用 @Tool 注解定义 tool 的描述

public static class TestTools {
    @Tool(description = "获取今天日期")
    String getCurrentDateTime() {
        System.out.println("======getCurrentDateTime");
        return LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy年MM月dd日"));
    }

    @Tool(description = "获取当前温度")
    String getCurrentTemperature(MyToolReques  toolReques) {
        System.out.println("======getCurrentTemperature: " + toolReques.localName + "__" + toolReques.date);
        return toolReques.date + toolReques.localName + "温度为20摄氏度";
    }

    public record MyToolReques(String localName, String date) {}
}

这里定义了两个方法，并通过注解的 description 参数告诉大模型方法的用途。

record 类型是 Java17 的新特性，可用于替代传统的 POJO 类。

3.2. 创建对话接口

private ChatMemory chatMemory = new InMemoryChatMemory();
private MessageChatMemoryAdvisor messageChatMemoryAdvisor = new MessageChatMemoryAdvisor(chatMemory);

@GetMapping(value = "/chat")
public String chat(@RequestParam String input, String sessionId, HttpServletResponse response) {
    response.setCharacterEncoding("UTF-8");

    return chatClient.prompt().user(input)
            .tools(new TestTools())
            .advisors(messageChatMemoryAdvisor)
            .advisors(spec -> spec
                    .param(MessageChatMemoryAdvisor.CHAT_MEMORY_CONVERSATION_ID_KEY, sessionId))
            .call()
            .content();
}

• tools 给大模型注册可以调用的方法。
• MessageChatMemoryAdvisor 实现聊天记忆，InMemoryChatMemory 为 SpringAI 自带的实现（基于内存）。
• 可以使用 CHAT_MEMORY_CONVERSATION_ID_KEY 参数指定对话ID，不同的会话ID用于隔离记忆。

3.3. 测试

通过后台打印信息可以看到大模型会自动识别，先调用 getCurrentDate 方法获取今天日期，再调用 getCurrentTemperature 方法获取天气。

======getCurrentDate

======getCurrentTemperature: 广州__2025年04月13日

加一个聊天框，测试多轮对话效果：

第二次会话直接输入 广州 大模型就知道我要问什么了，说明聊天记忆功能已生效。

四、总结

本文以问天气为场景，通过 Tool Calling 实现系统 API 调用，同时实现多轮对话中的会话记忆。需要注意的是 InMemoryChatMemory 只能作为测试使用，在企业应用中需要使用其他实现方式，把聊天记录存储在 Redis 或者 数据库中，并且需要考虑消息的保存时间、容量、如何清除等问题。

五、完整代码

• Gitee地址：

https://gitee.com/zlt2000/zlt-spring-ai-app

• Github地址：

https://github.com/zlt2000/zlt-spring-ai-app

来源： Spring AI与DeepSeek实战三：打造企业知识库 – zlt2000 – 博客园

一、概述

企业应用集成大语言模型（LLM）落地的两大痛点：

• 知识局限性：LLM依赖静态训练数据，无法覆盖实时更新或垂直领域的知识；
• 幻觉：当LLM遇到训练数据外的提问时，可能生成看似合理但错误的内容。

用最低的成本解决以上问题，需要使用 RAG 技术，它是一种结合信息检索技术与 LLM 的框架，通过从外部 知识库 动态检索相关上下文信息，并将其作为 Prompt 融入生成过程，从而提升模型回答的准确性;

本文将以AI智能搜索为场景，基于 Spring AI 与 RAG 技术结合，通过构建实时知识库增强大语言模型能力，实现企业级智能搜索场景与个性化推荐，攻克 LLM 知识滞后与生成幻觉两大核心痛点。

关于 Spring AI 与 DeepSeek 的集成，以及 API-KEY 的申请等内容，可参考文章《Spring AI与DeepSeek实战一：快速打造智能对话应用》

二、RAG数据库选择

构建知识库的数据库一般有以下有两种选择：

搜索推荐场景更适合选择 向量数据库

三、向量模型

向量模型是实现 RAG 的核心组件之一，用于将非结构化数据（如文本、图像、音频）转换为 高维向量（Embedding）的机器学习模型。这些向量能够捕捉数据的语义或结构信息，使计算机能通过数学运算处理复杂关系。

向量数据库是专门存储、索引和检索高维向量的数据库系统

spring-ai-alibaba-starter 默认的向量模型为 text-embedding-v1

可以通过 spring.ai.dashscope.embedding.options.model 进行修改。

四、核心代码

4.1. 构建向量数据

创建 resources/rag/data-resources.txt 文件，内容如下：

1. {"type":"api","name":"测试api服务01","topic":"综合政务","industry":"采矿业","remark":"获取采矿明细的API服务"}
2. {"type":"api","name":"新能源车类型","topic":"能源","industry":"制造业","remark":"获取新能源车类型的服务"}
3. {"type":"api","name":"罚款报告","topic":"交通","industry":"制造业","remark":"获取罚款报告的接口"}
4. {"type":"api","name":"光伏发电","topic":"能源","industry":"电力、热力、燃气及水生产和供应业","remark":"获取光伏发电的年度报告"}
5. {"type":"api","name":"收益明细2025","topic":"综合政务","industry":"信息传输、软件和信息技术服务业","remark":"2025年的收益明细信息表"}

创建向量数据库的 Bean

@Bean
public VectorStore vectorStore(EmbeddingModel embeddingModel
        , @Value("classpath:rag/data-resources.txt") Resource docs) {
    VectorStore vectorStore = SimpleVectorStore.builder(embeddingModel).build();
    vectorStore.write(new TokenTextSplitter().transform(new TextReader(docs).read()));
    return vectorStore;
}

• SimpleVectorStore 是 Spring AI 提供的一个基于内存的向量数据库；
• 使用 TokenTextSplitter 来切分文档。

4.2. 创建ChatClient

private final ChatClient chatClient;

public RagController(ChatClient.Builder builder, VectorStore vectorStore) {
    String sysPrompt = """
            您是一个数据产品的智能搜索引擎，负责根据用户输入的内容进行精准匹配、模糊匹配和近义词匹配，以搜索相关的数据记录。
            您只能搜索指定的内容，不能回复其他内容或添加解释。
            您可以通过[search_content]标识符来表示需要搜索的具体内容。要求您返回匹配内容的完整记录，以JSON数组格式呈现。
            如果搜索不到内容，请返回[no_data]。
            """;
    this.chatClient = builder
            .defaultSystem(sysPrompt)
            .defaultAdvisors(
                    new QuestionAnswerAdvisor(vectorStore, new SearchRequest())
            )
            .defaultOptions(
                    DashScopeChatOptions.builder()
                            .withModel("deepseek-r1")
                            .build()
            )
            .build();
}

• 通过系统 Prompt 来指定智能体的能力；
• 通过 QuestionAnswerAdvisor 绑定向量数据库。

4.3. 搜索接口

@GetMapping(value = "/search")
public List<SearchVo> search(@RequestParam String search, HttpServletResponse response) {
    response.setCharacterEncoding("UTF-8");
    PromptTemplate promptTemplate = new PromptTemplate("[search_content]: {search}");
    Prompt prompt = promptTemplate.create(Map.of("search", search));

    return chatClient.prompt(prompt)
            .call()
            .entity(new ParameterizedTypeReference<List<SearchVo>>() {});
}

这里通过 entity 方法来实现搜索结果以结构化的方式返回。

4.4. 测试接口

4.4.1. 搜索新能源

除了模糊匹配了新能源车之外，还匹配了和新能源相关的光伏数据。

4.4.21. 搜索收入

匹配同义词的收益数据。

五、总结

本文以智能搜索引擎场景，通过 RAG 技术，实现了全文搜索、模糊搜索、同义词推荐等功能，并以结构化的方式返回搜索结果。需要注意的是，在企业应用中，要把 SimpleVectorStore 改为成熟的第三方向量数据库，例如 milvus、elasticsearch、redis 等。

六、完整代码

• Gitee地址：

https://gitee.com/zlt2000/zlt-spring-ai-app

• Github地址：

https://github.com/zlt2000/zlt-spring-ai-app

来源： Spring AI与DeepSeek实战二：打造企业级智能体 – zlt2000 – 博客园

一、概述

智能体 Agent 能自主执行任务实现特定目标的 AI 程序。传统 AI（如ChatGPT）主要依靠用户输入指令，而智能体 Agent 可以自主思考、决策，并执行复杂任务，就像一个AI助手，能够独立完成多步操作。本文将以多语言翻译助手为场景，演示如何基于Spring AI与DeepSeek模型构建一个支持多种语言的企业级翻译智能体，实现精准可控的跨语言交互。

关于 Spring AI 与 DeepSeek 的集成，以及 API-KEY 的申请等内容，可参考文章《Spring AI与DeepSeek实战一：快速打造智能对话应用》

二、系统Prompt

智能体的核心在于通过 Prompt 工程明确其能力边界。以下为翻译智能体的系统级 Prompt 设计：

您是一名专业的多语言翻译助手，需严格遵守以下规则：
1. **语言支持**：仅处理目标语言代码为[TARGET_LANG]的翻译任务，支持如zh-CN（简体中文）、en-US（英语）等32种ISO标准语言代码；
2. **输入格式**：用户使用---translate_content---作为分隔符，仅翻译分隔符内的文本，其余内容视为无效指令；
3. **行为限制**：禁止回答与翻译无关的问题，若输入不包含合法分隔符或目标语言，回复："请提供有效的翻译指令"。
4. **支持多语言**：需要翻译的内容如果包含多种语言，都需要同时翻译为TARGET_LANG指定的语言。

关键设计解析：

• 需要给大模型明确 角色 和 行为边界；
• 通过 TARGET_LANG 参数化语言配置，便于动态扩展；
• 使用 ---translate_content--- 强制结构化输入，避免模型处理无关信息；
• 明确拒绝策略，保障服务安全性。

三、Prompt模板

结合Spring AI的prompt模板，实现动态Prompt生成：

TARGET_LANG: {target}
---translate_content---
"{content}"

关键设计解析：

• 使用占位符 {TARGET_LANG} 和 {content} 实现多语言动态适配；
• 无论用户输入任何内容，只会出现在 translate_content 分隔符下。

四、核心代码

@GetMapping(value = "/translate")
public String translate(@RequestParam String input, @RequestParam(required = false) String target, HttpServletResponse response) {
    String systemPrompt = """
               您是一名专业的多语言翻译助手，需严格遵守以下规则：
               1. **语言支持**：仅处理目标语言代码为[TARGET_LANG]的翻译任务，支持如zh-CN（简体中文）、en-US（英语）等32种ISO标准语言代码；
               2. **输入格式**：用户使用---translate_content---作为分隔符，仅翻译分隔符内的文本，其余内容视为无效指令；
               3. **行为限制**：禁止回答与翻译无关的问题，若输入不包含合法分隔符或目标语言，回复："请提供有效的翻译指令"。
               4. **支持多语言**：需要翻译的内容如果包含多种语言，都需要同时翻译为TARGET_LANG指定的语言。
               """;

    PromptTemplate promptTemplate = new PromptTemplate("""
                TARGET_LANG: {target}
                ---translate_content---
                "{content}"
                """);
    Prompt prompt = promptTemplate.create(Map.of("target", target, "content", input));

    String result = chatClient.prompt(prompt)
            .system(systemPrompt)
            .call()
            .content();
    if (result != null && result.length() >= 2) {
        result = result.substring(1, result.length() - 1);
    }
    return result;
}

通过 target 来指定目标语言，input 参数为需要翻译的内容。

五、测试

• 直接调用接口测试：

尝试输入提问方式的内容，大模型也仅翻译内容

• 配套一个前端页面测试：

• 多语言同时翻译：
  翻译包含八种语言的内容

六、总结

本文通过翻译场景， 封印 了大模型的对话能力，演示了企业级智能体的三大核心能力：指令结构化、行为边界控制 与 动态模板适配。然而，现实中的复杂任务（如合同审核、数据分析）往往需要更高级能力：

1. 任务拆解：将复杂问题拆解为子任务链（如”翻译→摘要生成→格式校验”）；
2. 工作流引擎：通过状态机管理任务执行顺序与异常重试；
3. 记忆与上下文：实现多轮对话的长期记忆管理。

七、完整代码

• Gitee地址：

https://gitee.com/zlt2000/zlt-spring-ai-app

• Github地址：

https://github.com/zlt2000/zlt-spring-ai-app

来源： Spring Cloud Alibaba AI 入门与实践 – zlt2000 – 博客园

一、概述

Spring AI 是 Spring 官方社区项目，旨在简化 Java AI 应用程序开发，让 Java 开发者像使用 Spring 开发普通应用一样开发 AI 应用。

• 可参考文章《SpringAI：Java 开发的智能新利器》

Spring Cloud Alibaba AI 是一个将 Spring Cloud 微服务生态与阿里巴巴 AI 能力无缝集成的框架，帮助开发者快速构建具备 AI 功能的现代化应用。本文将介绍 Spring Cloud Alibaba AI 的基本概念、主要特性和功能，并演示如何完成一个 在线聊天 和 在线画图 的 AI 应用。

二、主要特性和功能

Spring Cloud Alibaba AI 目前基于 Spring AI 0.8.1 版本 API 完成通义系列大模型的接入。通义接入是基于阿里云 阿里云百炼 服务；而 阿里云百炼 建立在 模型即服务（MaaS） 的理念基础之上，围绕 AI 各领域模型，通过标准化的 API 提供包括模型推理、模型微调训练在内的多种模型服务。

主要提供以下核心功能：

2.1. 简单易用的集成

通过 Spring Boot 风格的自动配置机制，开发者只需少量代码配置，即可快速接入阿里云的 AI 服务。

2.2. 丰富的 AI 服务支持

支持以下核心能力：

• 自然语言处理（NLP）：文本分析、智能问答、翻译。
• 计算机视觉（CV）：图像生成、图像识别、目标检测。
• 语音处理：语音识别、语音合成。
• 数据分析与预测：数据建模、趋势分析。

2.3. 高度扩展性

通过配置中心和注册中心（如 Nacos）实现动态扩展，支持微服务架构的扩展需求。
提供接口定义，方便接入第三方 AI 平台。

三、构建 AI 应用

Spring Cloud Alibaba AI 对 Java 版本有要求，所以需要提前预装好 Java 17 环境。

3.1. 申请 API-KEY

登录阿里云，进入 阿里云百炼 的页面：

https://bailian.console.aliyun.com/?apiKey=1#/api-key

创建自己的 API-KEY

3.2. 添加依赖

在 Spring Boot 项目的 pom.xml 中添加 alibaba-ai 依赖

<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-ai</artifactId>
</dependency>

<repositories>
    <repository>
        <id>alimaven</id>
        <url>https://maven.aliyun.com/repository/public</url>
    </repository>
    <repository>
        <id>spring-milestones</id>
        <url>https://repo.spring.io/milestone</url>
        <snapshots>
            <enabled>false</enabled>
        </snapshots>
    </repository>
    <repository>
        <id>spring-snapshots</id>
        <url>https://repo.spring.io/snapshot</url>
        <snapshots>
            <enabled>false</enabled>
        </snapshots>
    </repository>
</repositories>

3.3. 配置 API-KEY

在 application.yml 中配置 Kafka 的相关属性，包括服务器地址、认证信息等。

spring:
  cloud:
    ai:
      tongyi:
        connection:
          api-key: sk-xxxxxx

• api-key 配置在阿里云百炼里申请的api-key

3.4. 创建模型调用服务

@Service
@Slf4j
public class TongYiSimpleService {
    @Resource
    private TongYiChatModel chatClient;
    @Resource
    private TongYiImagesModel imageClient;

    public String chat(String message) {
        Prompt prompt = new Prompt(new UserMessage(message));
        return chatClient.call(prompt).getResult().getOutput().getContent();
    }

    public String image(String message) {
        ImagePrompt prompt = new ImagePrompt(message);
        Image image = imageClient.call(prompt).getResult().getOutput();
        return image.getB64Json();
    }
}

聊天和图片的服务，分别通过注入 TongYiChatModel 和 TongYiImagesModel 对象来实现，屏蔽底层通义大模型交互细节。

3.5. 创建controller

@RestController
@RequestMapping("/ai")
public class TongYiController {
    @Resource
    private TongYiSimpleService tongYiSimpleService;

    @GetMapping("/chat")
    public String chat(@RequestParam(value = "message") String message) {
        return tongYiSimpleService.chat(message);
    }

    @GetMapping("/image")
    public ResponseEntity<byte[]> image(@RequestParam(value = "message") String message) {
        String b64Str = tongYiSimpleService.image(message);
        byte[] imageBytes = Base64.getDecoder().decode(b64Str);
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.IMAGE_JPEG);
        return new ResponseEntity<>(imageBytes, headers, HttpStatus.OK);
    }
}

3.6. 测试效果

3.6.1. 聊天接口

在浏览器输入：http://localhost:8009/ai/chat?message=你是谁

3.6.2. 图片接口

在浏览器输入：http://localhost:8009/ai/image?message=意大利面拌42号混凝土

3.6.3. 搭配聊天页面

四、总结

当前版本的 Spring Cloud Alibaba AI 主要完成了几种常见生成式模型的适配，涵盖对话、文生图、文生语音等。在未来的版本中将继续推进 VectorStore、Embedding、ETL Pipeline、RAG 等更多 AI 应用开发场景的建设。

完整的样例代码下载：
https://gitee.com/zlt2000/spring-cloud-ai-sample

来源： MCP开发应用，使用python部署sse模式 – 肖祥 – 博客园

一、概述

MCP服务端当前支持两种与客户端的数据通信方式：标准输入输出(stdio)  和 基于Http的服务器推送事件(http sse)

二、MCP开发应用

MCP Server应用平台

MCP应用开发

解释

# MySQL数据库配置
MYSQL_HOST=192.168.20.128
MYSQL_PORT=3306
MYSQL_USER=root
MYSQL_PASSWORD=abcd@1234
MYSQL_DATABASE=test

这个是mysql连接信息

 

server.py

解释

import os

import uvicorn
from mcp.server.sse import SseServerTransport
from mysql.connector import connect, Error
from mcp.server import Server
from mcp.types import Tool, TextContent
from starlette.applications import Starlette
from starlette.routing import Route, Mount
from dotenv import load_dotenv


def get_db_config():
    """从环境变量获取数据库配置信息

    返回:
        dict: 包含数据库连接所需的配置信息
        - host: 数据库主机地址
        - port: 数据库端口
        - user: 数据库用户名
        - password: 数据库密码
        - database: 数据库名称

    异常:
        ValueError: 当必需的配置信息缺失时抛出
    """

    # 加载.env文件
    load_dotenv()

    config = {
        "host": os.getenv("MYSQL_HOST", "localhost"),
        "port": int(os.getenv("MYSQL_PORT", "3306")),
        "user": os.getenv("MYSQL_USER"),
        "password": os.getenv("MYSQL_PASSWORD"),
        "database": os.getenv("MYSQL_DATABASE"),
    }
    print(config)
    if not all([config["user"], config["password"], config["database"]]):
        raise ValueError("缺少必需的数据库配置")

    return config


def execute_sql(query: str) -> list[TextContent]:
    """执行SQL查询语句

    参数:
        query (str): 要执行的SQL语句，支持多条语句以分号分隔

    返回:
        list[TextContent]: 包含查询结果的TextContent列表
        - 对于SELECT查询：返回CSV格式的结果，包含列名和数据
        - 对于SHOW TABLES：返回数据库中的所有表名
        - 对于其他查询：返回执行状态和影响行数
        - 多条语句的结果以"---"分隔

    异常:
        Error: 当数据库连接或查询执行失败时抛出
    """
    config = get_db_config()
    try:
        with connect(**config) as conn:
            with conn.cursor() as cursor:
                statements = [stmt.strip() for stmt in query.split(";") if stmt.strip()]
                results = []

                for statement in statements:
                    try:
                        cursor.execute(statement)

                        # 检查语句是否返回了结果集 (SELECT, SHOW, EXPLAIN, etc.)
                        if cursor.description:
                            columns = [desc[0] for desc in cursor.description]
                            rows = cursor.fetchall()

                            # 将每一行的数据转换为字符串，特殊处理None值
                            formatted_rows = []
                            for row in rows:
                                formatted_row = [
                                    "NULL" if value is None else str(value)
                                    for value in row
                                ]
                                formatted_rows.append(",".join(formatted_row))

                            # 将列名和数据合并为CSV格式
                            results.append(
                                "\n".join([",".join(columns)] + formatted_rows)
                            )

                        # 如果语句没有返回结果集 (INSERT, UPDATE, DELETE, etc.)
                        else:
                            conn.commit()  # 只有在非查询语句时才提交
                            results.append(f"查询执行成功。影响行数: {cursor.rowcount}")

                    except Error as stmt_error:
                        # 单条语句执行出错时，记录错误并继续执行
                        results.append(
                            f"执行语句 '{statement}' 出错: {str(stmt_error)}"
                        )
                        # 可以在这里选择是否继续执行后续语句，目前是继续

                return [TextContent(type="text", text="\n---\n".join(results))]

    except Error as e:
        print(f"执行SQL '{query}' 时出错: {e}")
        return [TextContent(type="text", text=f"执行查询时出错: {str(e)}")]


def get_table_name(text: str) -> list[TextContent]:
    """根据表的中文注释搜索数据库中的表名

    参数:
        text (str): 要搜索的表中文注释关键词

    返回:
        list[TextContent]: 包含查询结果的TextContent列表
        - 返回匹配的表名、数据库名和表注释信息
        - 结果以CSV格式返回，包含列名和数据
    """
    config = get_db_config()
    sql = "SELECT TABLE_SCHEMA, TABLE_NAME, TABLE_COMMENT "
    sql += f"FROM information_schema.TABLES WHERE TABLE_SCHEMA = '{config['database']}' AND TABLE_COMMENT LIKE '%{text}%';"
    return execute_sql(sql)


def get_table_desc(text: str) -> list[TextContent]:
    """获取指定表的字段结构信息

    参数:
        text (str): 要查询的表名，多个表名以逗号分隔

    返回:
        list[TextContent]: 包含查询结果的TextContent列表
        - 返回表的字段名、字段注释等信息
        - 结果按表名和字段顺序排序
        - 结果以CSV格式返回，包含列名和数据
    """
    config = get_db_config()
    # 将输入的表名按逗号分割成列表
    table_names = [name.strip() for name in text.split(",")]
    # 构建IN条件
    table_condition = "','".join(table_names)
    sql = "SELECT TABLE_NAME, COLUMN_NAME, COLUMN_COMMENT "
    sql += (
        f"FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = '{config['database']}' "
    )
    sql += f"AND TABLE_NAME IN ('{table_condition}') ORDER BY TABLE_NAME, ORDINAL_POSITION;"
    return execute_sql(sql)

def get_lock_tables() -> list[TextContent]:
    sql = """SELECT
    p2.`HOST` AS 被阻塞方host,
    p2.`USER` AS 被阻塞方用户,
    r.trx_id AS 被阻塞方事务id,
    r.trx_mysql_thread_id AS 被阻塞方线程号,
    TIMESTAMPDIFF(SECOND, r.trx_wait_started, CURRENT_TIMESTAMP) AS 等待时间,
    r.trx_query AS 被阻塞的查询,
    l.OBJECT_NAME AS 阻塞方锁住的表,
    m.LOCK_MODE AS 被阻塞方的锁模式,
    m.LOCK_TYPE AS '被阻塞方的锁类型(表锁还是行锁)',
    m.INDEX_NAME AS 被阻塞方锁住的索引,
    m.OBJECT_SCHEMA AS 被阻塞方锁对象的数据库名,
    m.OBJECT_NAME AS 被阻塞方锁对象的表名,
    m.LOCK_DATA AS 被阻塞方事务锁定记录的主键值,
    p.`HOST` AS 阻塞方主机,
    p.`USER` AS 阻塞方用户,
    b.trx_id AS 阻塞方事务id,
    b.trx_mysql_thread_id AS 阻塞方线程号,
    b.trx_query AS 阻塞方查询,
    l.LOCK_MODE AS 阻塞方的锁模式,
    l.LOCK_TYPE AS '阻塞方的锁类型(表锁还是行锁)',
    l.INDEX_NAME AS 阻塞方锁住的索引,
    l.OBJECT_SCHEMA AS 阻塞方锁对象的数据库名,
    l.OBJECT_NAME AS 阻塞方锁对象的表名,
    l.LOCK_DATA AS 阻塞方事务锁定记录的主键值,
    IF(p.COMMAND = 'Sleep', CONCAT(p.TIME, ' 秒'), 0) AS 阻塞方事务空闲的时间
    FROM performance_schema.data_lock_waits w
    INNER JOIN performance_schema.data_locks l ON w.BLOCKING_ENGINE_LOCK_ID = l.ENGINE_LOCK_ID
    INNER JOIN performance_schema.data_locks m ON w.REQUESTING_ENGINE_LOCK_ID = m.ENGINE_LOCK_ID
    INNER JOIN information_schema.INNODB_TRX b ON b.trx_id = w.BLOCKING_ENGINE_TRANSACTION_ID
    INNER JOIN information_schema.INNODB_TRX r ON r.trx_id = w.REQUESTING_ENGINE_TRANSACTION_ID
    INNER JOIN information_schema.PROCESSLIST p ON p.ID = b.trx_mysql_thread_id
    INNER JOIN information_schema.PROCESSLIST p2 ON p2.ID = r.trx_mysql_thread_id
    ORDER BY 等待时间 DESC;"""

    return execute_sql(sql)


# 初始化服务器
app = Server("operateMysql")


@app.list_tools()
async def list_tools() -> list[Tool]:
    """列出可用的MySQL工具

    返回:
        list[Tool]: 工具列表，当前仅包含execute_sql工具
    """
    return [
        Tool(
            name="execute_sql",
            description="在MySQL8.0数据库上执行SQL",
            inputSchema={
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "要执行的SQL语句"}
                },
                "required": ["query"],
            },
        ),
        Tool(
            name="get_table_name",
            description="根据表中文名搜索数据库中对应的表名",
            inputSchema={
                "type": "object",
                "properties": {
                    "text": {"type": "string", "description": "要搜索的表中文名"}
                },
                "required": ["text"],
            },
        ),
        Tool(
            name="get_table_desc",
            description="根据表名搜索数据库中对应的表结构,支持多表查询",
            inputSchema={
                "type": "object",
                "properties": {
                    "text": {"type": "string", "description": "要搜索的表名"}
                },
                "required": ["text"],
            },
        ),
        Tool(
            name="get_lock_tables",
            description="获取当前mysql服务器InnoDB 的行级锁",
            inputSchema={"type": "object", "properties": {}},
        ),
    ]


@app.call_tool()
async def call_tool(name: str, arguments: dict) -> list[TextContent]:

    if name == "execute_sql":
        query = arguments.get("query")
        if not query:
            raise ValueError("缺少查询语句")
        return execute_sql(query)
    elif name == "get_table_name":
        text = arguments.get("text")
        if not text:
            raise ValueError("缺少表信息")
        return get_table_name(text)
    elif name == "get_table_desc":
        text = arguments.get("text")
        if not text:
            raise ValueError("缺少表信息")
        return get_table_desc(text)
    elif name == "get_lock_tables":
        return get_lock_tables()

    raise ValueError(f"未知的工具: {name}")


sse = SseServerTransport("/messages/")


# Handler for SSE connections
async def handle_sse(request):
    async with sse.connect_sse(
        request.scope, request.receive, request._send
    ) as streams:
        await app.run(streams[0], streams[1], app.create_initialization_options())


# Create Starlette app with routes
starlette_app = Starlette(
    debug=True,
    routes=[
        Route("/sse", endpoint=handle_sse),
        Mount("/messages/", app=sse.handle_post_message),
    ],
)


if __name__ == "__main__":
    uvicorn.run(starlette_app, host="0.0.0.0", port=9000)

这里面，主要提供了4个工具方法，分别是：

execute_sql
get_table_name
get_table_desc
get_lock_tables

pip install mcp
pip install mysql-connector-python
pip install uvicorn
pip install python-dotenv
pip install starlette

python server.py

INFO:     Started server process [23756]
INFO:     Waiting for application startup.
INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:9000 (Press CTRL+C to quit)
INFO:     127.0.0.1:60896 - "GET /sse HTTP/1.1" 200 OK

客户端添加MCP

来源： AI作曲神器加持！零基础也能玩转音乐副业，解锁你的创作新技能！ – 国外网赚博客

来源： C# LINQ 快速入门实战指南，建议收藏学习！ – 追逐时光者 – 博客园

C# LINQ 快速入门实战指南，建议收藏学习！

        public class StudentInfo
        {
            public int StudentID { get; set; }
            public string StudentName { get; set; }
            public DateTime Birthday { get; set; }
            public int ClassID { get; set; }
            public string Address { get; set; }
            public List<Course> Courses { get; set; } = new List<Course>();
        }

        public class Course
        {
            public int CourseID { get; set; }
            public string CourseName { get; set; }
        }

        static List<StudentInfo> students = new List<StudentInfo>
        {
            new StudentInfo
            {
                StudentID=1,
                StudentName="大姚",
                Birthday=Convert.ToDateTime("1997-10-25"),
                ClassID=101,
                Courses = new List<Course>
                {
                    new Course { CourseID = 101, CourseName = "语文" },
                    new Course { CourseID = 102, CourseName = "数学" }
                }
            },
            new StudentInfo
            {
                StudentID=2,
                StudentName="李四",
                Birthday=Convert.ToDateTime("1998-10-25"),
                ClassID=101,
                Courses = new List<Course>
                {
                    new Course { CourseID = 101, CourseName = "语文" },
                    new Course { CourseID = 102, CourseName = "数学" }
                }
            },
            new StudentInfo
            {
                StudentID=3,
                StudentName="王五",
                Birthday=Convert.ToDateTime("1999-10-25"),
                ClassID=102,
                Address="广州",
                Courses = new List<Course>
                {
                    new Course { CourseID = 101, CourseName = "语文" },
                    new Course { CourseID = 102, CourseName = "数学" }
                }
            },
            new StudentInfo
            {
                StudentID=4,
                StudentName="时光者",
                Birthday=Convert.ToDateTime("1999-11-25"),
                ClassID=102,
                Address="深圳" ,
                Courses = new List<Course>
                {
                    new Course { CourseID = 104, CourseName = "历史" },
                    new Course { CourseID = 103, CourseName = "地理" }
                }
            }
        };

            var femaleStudents = students.Where(s => s.StudentName == "时光者");
            var studentNames = students.Select(s => s.StudentName);

            // 使用SelectMany展平所有学生的课程列表
            var allCourses = students.SelectMany(student => student.Courses).ToList();

            // 输出所有课程的名称
            foreach (var course in allCourses)
            {
                Console.WriteLine(course.CourseName);
            }

            var studentList = students.ToList();
            var studentArray = students.ToArray();
            var studentDictionary = students.ToDictionary(s => s.StudentID, s => s.StudentName);
            var studentLookup = students.ToLookup(s => s.ClassID, s => s.StudentName);

            var firstStudent = students.First();
            var firstAdult = students.FirstOrDefault(s => s.Birthday <= DateTime.Now.AddYears(-18));
            var onlyWangWu = students.Single(s => s.StudentName == "王五");
            var wangWuOrDefault = students.SingleOrDefault(s => s.StudentName == "王六");
            var lastStudent = students.Last();
            var lastAdult = students.LastOrDefault(s => s.Birthday <= DateTime.Now.AddYears(-18));
            var secondStudent = students.ElementAt(1);
            var tenthStudentOrDefault = students.ElementAtOrDefault(9);
            var nonEmptyStudents = students.DefaultIfEmpty(new StudentInfo { StudentID = 0, StudentName = "默认Student", Address = "默认" });

            var sortedByBirthdayAsc = students.OrderBy(s => s.Birthday);
            var sortedByClassIDDesc = students.OrderByDescending(s => s.ClassID);
            var sortedByNameThenClassID = students.OrderBy(s => s.StudentName).ThenBy(s => s.ClassID);
            var sortedThenByDescending = students.OrderBy(s => s.StudentName).ThenBy(s => s.ClassID).ThenByDescending(x => x.Birthday);

            int studentCount = students.Count();
            int totalClassID = students.Sum(s => s.ClassID);
            double averageAge = students.Average(s => DateTime.Now.Year - s.Birthday.Year);
            int minClassID = students.Min(s => s.ClassID);
            int maxClassID = students.Max(s => s.ClassID);
            string concatenatedNames = students.Aggregate("", (acc, s) => acc == "" ? s.StudentName : acc + ", " + s.StudentName);

            var uniqueClassIDs = students.Select(s => s.ClassID).Distinct();
            var unionClassIDs = uniqueClassIDs.Union(new[] { 103, 104 });
            var intersectClassIDs = uniqueClassIDs.Intersect(new[] { 101, 103 });
            var exceptClassIDs = uniqueClassIDs.Except(new[] { 101 });
            var concatClassIDs = uniqueClassIDs.Concat(new[] { 103, 104 });

  var groupedByClassID = students.GroupBy(s => s.ClassID);
  var otherStudent = new List<StudentInfo>
  {
     new StudentInfo
     {
         StudentID=4,
         StudentName="摇一摇",
         Birthday=Convert.ToDateTime("2997-10-25"),
         ClassID=101,
         Courses = new List<Course>
         {
             new Course { CourseID = 101, CourseName = "语文" },
             new Course { CourseID = 102, CourseName = "数学" }
         }
     }
  };
  var listJoin = students.Join(
      otherStudent, // 要连接的第二个序列
      s1 => s1.StudentID, // 从第一个序列中提取键
      s2 => s2.StudentID, // 从第二个序列中提取键
      (s1, s2) => new // 结果选择器，指定如何从两个匹配元素创建结果
      {
          StudentID = s1.StudentID,
          StudentName = s1.StudentName,
          Birthday = s1.Birthday,
          ClassID = s1.ClassID,
          Address = s1.Address,
          Courses = s1.Courses,
          OtherStudentName = s2.StudentName //假设我们想要包含第二个序列中学生的名称
      });

            var skippedStudents = students.Skip(1);
            var takenStudents = students.Take(2);

            //数据分页查询（Skip + Take）
            int pageNumber = 2;
            int pageSize = 10;
            var pagedUsers = skippedStudents
                .OrderBy(u => u.ClassID) // 必须排序
                .Skip((pageNumber - 1) * pageSize)
                .Take(pageSize)
                .ToList();

            bool allAdults = students.All(s => s.Birthday <= DateTime.Now.AddYears(-18));
            bool anyAdults = students.Any(s => s.Birthday <= DateTime.Now.AddYears(-18));
            bool containsWangWu = students.Contains(students.First(s => s.StudentName == "王五"));

            var querySyntaxResult = from student in students
                                    where student.ClassID == 101
                                    orderby student.StudentName ascending
                                    select student;

            Console.WriteLine("查询语法结果:");
            foreach (var student in querySyntaxResult)
            {
                Console.WriteLine($"{student.StudentName}, ClassID: {student.ClassID}");
            }

            var methodSyntaxResult = students
                                    .Where(student => student.ClassID == 101)
                                    .OrderBy(student => student.StudentName)
                                    .ToList();


            Console.WriteLine("方法语法结果:");
            foreach (var student in methodSyntaxResult)
            {
                Console.WriteLine($"{student.StudentName}, ClassID: {student.ClassID}");
            }

            var mixedResult = (from student in students
                               where student.ClassID == 101
                               where student.Courses.Any(course => course.CourseName == "数学")
                               orderby student.StudentName ascending
                               select student)
                       .Take(2)
                       .ToList();

            // 输出结果
            Console.WriteLine("混合查询结果:");
            foreach (var student in mixedResult)
            {
                Console.WriteLine($"{student.StudentName}, ClassID: {student.ClassID}");
            }

来源： openglasses项目软件代码改造 – 知乎

一、项目地址

https://github.com/BasedHardware/OpenGlass/blob/main/package.json

二、代码成分

分硬件+软件两部分

三、项目介绍

这个项目是使用seeed studio XIAO esp32S3 sense这块开发版作为蓝牙模块（释放的蓝牙不是平时手机能搜到的那种蓝牙）

1、然后适配硬件代码，可以支持每N秒拍一次照片；

2、在软件项目中支持对每次拍到的照片进行【图片解释】，以及可以进行对话并使用历史所有的图片解释内容进行回答（回答不仅有文本，还有语音播放）

四、在网上这个项目的如何搭建的文档有很多，这里列举几个

我用OpenGlass做了一个AI眼镜【上篇】 | Rocket Lu

https://mp.weixin.qq.com/mp/wappoc_appmsgcaptcha?poc_token=HFPIY2ejRQcCQzcGQ_r6lROAvDuWUA47KiEpqxC0&target_url=https%3A%2F%2Fmp.weixin.qq.com%2Fs%2FO_rENZfu5pXn-cF9_z-gzQ%3F

五分钟——配置OpenGlass的硬件

五、源码改造

这篇文章主要是把作者在修改软件代码时的一些源码进行分享，因为软件代码中有地方用到ollma、grop、openai，这些直接用起来都不是很方便，比如ollma需要在本地进行安装，需要电脑的配置很高；grop是国外的；openai直接无法访问

1、用ollma进行图像解释，暂时只有两种方案，第一种是和原代码中一样，使用大模型来进行对话解释，国内暂时只有【阿里的通义千问】能做到这点；第二种是用传统的sdk/api方式，暂时只有【百度】可以做到这点，但是百度的接口有些麻烦，要连续调两个接口才行（第一个接口时返回一个reqid，第二个是用这个reqid来获取接口）

// 定义MessageContent接口
interface MessageContent {
    type: string;
    text?: string;
    image_url?: {
        url: string;
    };
}
// 定义Message接口
interface Message {
    role: string;
    content: MessageContent[];
}
export type KnownModelQianwen =
    | 'qwen-vl-max-latest'
    | 'qwen-vl-plus'
    | 'qwen-vl-max'

export async function qianwenInference(args: {
    model: string,
    messages: Message[]
}) {
    const token: string = keys.qianwen_key;
    const headers: { [key: string]: string } = {
        "Content-Type": "application/json", "Authorization": `Bearer ${token}`
    }

    const response = await backoff<any>(async () => {

        let converted: { role: string, content: MessageContent[] }[] = [];
        for (let message of args.messages) {
            console.log("message=", message)
            let content_tmp: MessageContent[] = []
            
            for (let content of message.content) {
                content_tmp.push({
                    type: content.type,
                    text: content.text ? trimIdent(content.text) : undefined,
                    image_url: content.image_url ? {
                        url: content.image_url.url
                    } : undefined
                })
            }
            converted.push({
                role: message.role,
                content: content_tmp
            });
        }
        const payload = {
            model: args.model,
            messages: converted,
        }
        let resp = await axios.post(keys.qianwen, payload, {
            headers: headers
        });
        // console.log("resp=",resp)
        return resp['data']["choices"][0]["message"]["content"];

    });
    return trimIdent(((response ?? '') as string));
}

2、grop的目的是单纯的大模型对话，原则上用哪个http api接口/sdk都可以。但是有个细节需要注意，这个细节就可以筛选掉一大批的选择，几乎所有的node.js对应的sdk都用到了node里面的util包，但是这个包在浏览器里面是不支持的，react前端项目在启动的时候，会生成localhost:8081，这个需要在浏览器进行访问，所以所有的sdk都可以放弃了。

只能使用http api的方式用axios来进行请求，百度、阿里的都可以。但是百度的这个http api还有个不太好的地方，无法直接用localhost:8081来调用他们的api，会报错：from origin ‘http://localhost:8081’ has been blocked by CORS policy: No ‘Access-Control-Allow-Origin’ header is present on the requested resource.。但是阿里的不会，所以我们选用阿里的即可

如果真的想用百度的，可以启动一个解除web安装策略的浏览器窗口，就不会报这种跨域错误了，命令如下：

cd C:\Program Files\Google\Chrome\Application>
chrome.exe --user-data-dir="C://Chrome dev session" --disable-web-security

下面给下阿里的通义接口

const token: string = keys.qianwen_key;
const headers: { [key: string]: string } = {
    "Content-Type": "application/json", "Authorization": `Bearer ${token}`
}
export async function tongyiRequest(systemPrompt: string, userPrompt: string) {
    try {
        console.info("Calling tongyiRequest qwen-plus")
        const response = await axios.post(keys.qianwen, {
            model: "qwen-plus",
            messages: [
                { role: "system", content: systemPrompt },
                { role: "user", content: userPrompt },
            ],
        }, { headers });
        console.info("tongyiRequest response = ", response)
        return response.data.choices[0].message.content;
    } catch (error) {
        console.error("Error in groqRequest:", error);
        return null; // or handle error differently
    }
}

3、openai的tts接口，就是文本转语音接口。作者测试了腾讯、百度、阿里、微软、讯飞等平台的接口，发现百度的最简单使用，其他的都不满足使用，这里直接给出百度的代码

attention：直接用也会报跨域错误，要用前面第2点提到的解决办法

const AK = "**"
const SK = "**"

/**
 * 使用 AK，SK 生成鉴权签名（Access Token）
 * @return string 鉴权签名信息（Access Token）
 */
function getAccessToken() {

    let options = {
        'method': 'POST',
        'url': 'https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials&client_id=' + AK + '&client_secret=' + SK,
    }
    return new Promise((resolve, reject) => {
        axios(options)
            .then(res => {
                resolve(res.data.access_token)
            })
            .catch(error => {
                reject(error)
            })
    })
}

export async function BaiduHttpApiTextToSpeech(text: string) {
    console.log("BaiduHttpApiTextToSpeechtext = ", text)
    const token = getAccessToken()
    console.log("BaiduHttpApiTextToSpeech token = ", token)
    
    const response = await axios.post("https://tsn.baidu.com/text2audio", {
                'tex': text,
                'tok': await getAccessToken(),
                'cuid': 'XB1oEeNOJVjS5oYGQYlbdrWDwPcIJbCP',
                'ctp': '1',
                'lan': 'zh',
                'spd': '5',
                'pit': '5',
                'vol': '5',
                'per': '1',
                'aue': '3'
            }, {
            headers: {
                'Content-Type': 'application/x-www-form-urlencoded',
                'Accept': '*/*'
            },
            responseType: 'arraybuffer'  // This will handle the binary data correctly 这将正确处理二进制数据
        });

    console.log("BaiduHttpApiTextToSpeech response=", response)
    // Decode the audio data asynchronously
    const audioBuffer = await audioContext.decodeAudioData(response.data);

    // Create an audio source
    const source = audioContext.createBufferSource();
    source.buffer = audioBuffer;
    source.connect(audioContext.destination);
    source.start();  // Play the audio immediately
}

六、启动

npm start启动后，就可以测试上面的功能了

来源： 基于Docker+DeepSeek+Dify ：搭建企业级本地私有化知识库超详细教程 – 但风偏偏，雨渐渐 – 博客园

　　　　本次演示部署环境：Windows 10专业版，转载请说明出处

下载安装Docker

　　Docker官网：https://www.docker.com/

自定义Docker安装路径

Docker默认安装在C盘，大小大概2.9G，做这行最忌讳的就是安装软件全装C盘，所以我调整了下安装路径。

新建安装目录：E:\MySoftware\Docker并将Docker安装包放在目录内，这里有个小细节，安装包名称一定要改下，官网下载下来的名称叫：Docker Desktop Installer.exe，一定要修改一下，不能用这个名字，否则等下在CMD命令安装的时候就会报错说被资源占用，因为Docker在安装时会解压一个一模一样名称的exe程序，重名就会导致安装失败，所以一定要改下名字。

　　在文件路径输入cmd回车

输入：

.\"Docker.exe" install --installation-dir=E:\MySoftware\Docker

语法：.\”安装程序名称” install --installation-dir=指定Docker安装的路径

 　　安装完成后会提示Installation sueceeded

　　桌面会出现Docker图标

　　启动Docker这里很多人会报这个错，这个是因为电脑没有WSL导致无法启动Docker容器。

下载WSL

　　进入微软官网按步骤执行即解决，几分钟完成。

https://learn.microsoft.com/zh-cn/windows/wsl/install-manual#step-4—download-the-linux-kernel-update-package

　　用管理员身份打开Powershell窗口，粘贴微软官网的命令执行下载即可

粘贴执行：

dism.exe /online /enable-feature /featurename:Microsoft-Windows-Subsystem-Linux /all /norestart

dism.exe /online /enable-feature /featurename:VirtualMachinePlatform /all /norestart

wsl --set-default-version 2

　　下载完后会启动一个这个页面，可以关闭。

　　注：完成内核更新包安装后需重启系统（微软官方指南），再启动下Docker，出现这个界面就代表WSL和Docker都启动成功了。

Docker镜像存储迁移

这时进入Docker设置中，将Docker的镜像资源存放路径改一下，不然都会下载都C盘。

Docker镜像源加速配置

至关重要的地方来了，打开Docker的设置中的–>Docker Engine，然后把国内的镜像源复制进去保存，我这里提供一些，如果失效了就百度找新的。

解释

{
"registry-mirrors": [
"https://docker.m.daocloud.io",
"https://noohub.ru",
"https://huecker.io",
"https://dockerhub.timeweb.cloud",
"https://0c105db5188026850f80c001def654a0.mirror.swr.myhuaweicloud.com",
"https://5tqw56kt.mirror.aliyuncs.com",
"https://docker.1panel.live",
"http://mirrors.ustc.edu.cn/",
"http://mirror.azure.cn/",
"https://hub.rat.dev/",
"https://docker.ckyl.me/",
"https://docker.chenby.cn",
"https://docker.hpcloud.cloud",
"https://docker.m.daocloud.io"
]
}

保存镜像源后就可以试一下拉取镜像，如果拉取不成功也可以重启下Docker，还是不行提示超时就说明镜像源失效了，就在网上搜索下新的镜像源。

测试拉取镜像

在cmd命令窗口输入：

docker pull hello-world

出现这个Status: Dowloaded newer image for hello-world:latest就代表镜像源没有问题。

安装Dify

下载Dify代码包

进入github下载Dify代码包：https://github.com/langgenius/dify

解压代码包后，把压缩后的文件夹复制到自己想要安装的目录下，这里复制一下.env.example文件，然后重命名一下改成.env

　　在当前文件路径下输入CMD回车

拉取Dify依赖镜像资源

　　粘贴以下命令回车，会自动下载一些依赖资源。如果你的下载失败就是镜像源失效了，换一个镜像源，重新拉取镜像。

docker-compose up -d

下载完成

　　回到Docker可以都看到已经下载好的镜像全部都显示了，并且都在运行。

进入Dify后台

输入http://127.0.0.1/会自动打开Dify的页面，有人会遇到这个Internal Server Error报错，这是因为镜像下载来后，有部分镜像还在启动中或未启动，这时候将所有镜像重启一次才可以。

　　重启所有镜像

创建管理员用户

　　重新进入Dify管理后台，首次进入需创建管理员用户。

创建管理员用户后，将进入登录界面。

登录成功

添加AI模型

点击右上角头像-设置

成员这里可以创建企业内成员进行登录使用。

选择模型供应商

这里我本地已经安装部署好了Ollama和Deepseek R1和BGE-M3模型，如果没有部署好的请看我这篇文章：本地电脑部署DeepSeek 大模型AI

　　由于我本地已经安装好了Ollama，所以就找到Ollama，点击安装插件，其他供应商选择对应安装。下载可能稍慢，请耐心等待。

添加模型时，若不知模型名称，可在CMD中输入Ollama list查看本地模型名称并复制。

模型类型：

推理模型 → LLM
嵌入模型 → Text Embedding

模型名称就把刚刚复制下来的粘贴上去就可以了。

这里IP地址要注意了，由于我没有用Docker容器里部署Ollama，而是在本地电脑安装的Ollama，这里对IP就要进行特殊处理下了，需要改为：http://host.docker.internal:11434。

网络通信原理：
host.docker.internal为Docker内置域名解析，实现容器与宿主机服务的桥接。简单说就是Docker自己和我们电脑主机网络做了一个映射关系。

模型添加完成

创建应用

其实我也不太会使用，就简单粗糙的做个示范吧，要深入研究需要找下资料学习下。

这里我选择创建聊天助手（每个不同应用的作用不一样，选择与自己相符的就行）

添加一些提示词、变量、知识库、模型，设置好后在右边可以调试预览效果，调试完成后就可以发布应用了。

这里提一句，由于我自己的电脑资源很一般，所以每次一提问的时候资源就占比很高，不过等AI思考完毕后资源占用会下降。

测试结果，虽然回答是错误的。

知识库测试

我这里测试了下知识库检索，上传了6个本地文档。

然后我简单的定义了提示词后，对模型提出问题：结合知识库帮我找出住在向阳里桃源弄的人员的电话和姓名。

然后真的回答对了，全体起立！

这是源文件里的内容。

WSL资源控制

由于我是针对个人学习，在学习完后我发现我的电脑内存占比一直居高不下，在任务管理器查到了是一个Vmmem的进程占用，大概也知道应该是虚拟机类的占用。

搜索了下网上资源了解到vmmem是一个由WSL（Windows Subsystem for Linux）创建的虚拟进程，主要用于管理WSL2的内存和CPU资源。当WSL2运行时，Vmmem进程会占用大量的内存和CPU资源，以确保虚拟机的最佳性能。然而，这可能会导致主机系统的其他应用程序运行缓慢或无法正常运行‌。

关闭WSL服务

所以如果不用的时候可以关闭掉WSL服务。

在cmd里输入：

wsl --shutdown

关闭后电脑资源就回到正常状态了。

启动WSL服务

那如果我们后再用的时候就重新启动WSL服务就可以。

在cmd输入：

wsl

最后的最后

关于Dify的作用文中提到的只是冰山一角，它真正的厉害之处是它的工作流，由于博主知识有限，只能教大家部署应用，具体的功能开发使用还要大家自行学习，后续博主也会去学习Dify的相关知识，有机会的话就再开一贴。如有讲的不对的地方，敬请指正。

附上Dify的官方操作手册地址：https://docs.dify.ai/zh-hans

这是我整个学习过程中遇到的问题，最后结合百度和AI最后都完成解决了。

总结几个小坑：

1、WSL2的安装。

2、Docker容器镜像源的设置。

3、Dify依赖镜像的拉取。

4、Dify添加模型时IP映射设置。

觉得不错的麻烦大家动动发财的小手点下推荐，谢谢！！！