如果你正在开发或使用 AI 智能体，大概率遇到过这样的困境：多个智能体之间如何高效、可靠地共享和协作处理文件？是让它们直接读写同一个文件夹，然后祈祷不会出现并发冲突？还是为每个任务都写一套复杂的消息传递和状态同步逻辑？

最近，一个名为 PuppyOne 的开源项目，提出了一个看似简单却直击痛点的方案： 用文件系统作为 AI 智能体的共享工作区 。这听起来像是“把大象关进冰箱”的第一步——打开冰箱门。但关键在于，它不只是“用”文件系统，而是重新定义了智能体与文件系统交互的“协议”，让文件系统本身成为智能体协作的“协调者”。

本文将深入解析 PuppyOne 的设计理念、核心原理，并通过一个完整的实战示例，带你从零搭建一个基于文件系统进行协作的多智能体系统。你会发现，这个方案真正降低的，不是存储成本，而是 智能体间状态同步与协作的认知与工程复杂度 。

1. 这篇文章真正要解决的问题

在传统的多智能体架构中，协作是个难题。假设你有两个智能体：一个负责分析数据（Analyst），一个负责生成报告（Reporter）。Analyst 需要将处理好的中间数据交给 Reporter。常见的做法有：

  1. 通过消息队列/总线传递 ：将数据序列化后发送。问题：大数据文件传输效率低，需要额外的序列化/反序列化开销，且状态管理复杂。
  2. 共享数据库/对象存储 ：Analyst 写入，Reporter 读取。问题：需要引入外部服务，增加了系统依赖和运维成本，并且“文件”的语义（如目录结构、临时文件）难以直接映射。
  3. 直接操作共享目录 ：最简单，也最危险。智能体A在写入文件时，智能体B可能正在读取，导致读到不完整或错误的数据。缺乏原子性操作和锁机制，极易产生竞态条件。

PuppyOne 的核心判断是 ：文件系统本身就是一个成熟、稳定、具备丰富语义（文件、目录、链接、权限）的状态管理工具。我们缺的不是存储介质，而是一套能让智能体像人类团队一样，通过“共享文件夹”进行安全、有序协作的“行为规范”和“工具套件”。

因此，本文要解决的核心问题是： 如何利用 PuppyOne，将普通的文件系统升级为智能体间安全、可靠、高效的共享协作工作区，从而简化多智能体系统的开发。 如果你正在构建涉及文件处理、流水线作业的多智能体应用，或者对智能体间的状态共享感到头疼，那么这篇文章正是为你准备的。

2. PuppyOne 基础概念与核心原理

在深入代码之前，我们需要理解几个关键概念，这能帮你明白 PuppyOne 到底在做什么，而不仅仅是调用几个 API。

2.1 核心思想：文件系统即协调层

PuppyOne 不替代你的文件系统（如 ext4, NTFS），也不替代你的智能体框架（如 LangChain, LangGraph）。它扮演的是一个 “适配器” 或 “协议层” 的角色。

  • 对智能体而言 ：PuppyOne 提供了一套客户端库。智能体通过这套库来执行文件操作（读、写、创建、删除），就像调用普通文件 API 一样。
  • 对文件系统而言 ：PuppyOne 的服务端（或中间件）拦截了这些操作，并在背后注入了一套 协作规则 。例如，它可以实现“文件锁”来防止写冲突，记录操作日志用于审计和回滚，或者提供“信号量”文件来协调多个智能体的执行顺序。

简单说，PuppyOne 让智能体们“认为”它们在操作一个普通的共享文件夹，但实际上，这个文件夹被一个“智能管家”管理着，确保了协作的秩序。

2.2 核心组件

一个典型的 PuppyOne 协作系统包含以下部分：

  1. PuppyOne 服务端 (Server) ：可以是独立的守护进程，也可以作为库嵌入到你的应用中。它负责管理共享工作区的根目录，并强制执行协作策略（如锁机制）。
  2. 共享工作区 (Shared Workspace) ：一个普通的文件系统目录，被 PuppyOne 服务端托管。所有智能体的协作都发生在这个目录树下。
  3. 智能体客户端 (Agent Client) ：集成到各个智能体中的 PuppyOne 客户端 SDK。智能体通过它来访问共享工作区，而不是直接使用 os.open 或 open() 。
  4. 协调原语 (Coordination Primitives) ：这是 PuppyOne 的灵魂。它借鉴了操作系统和分布式系统的思想，提供了：
    • 文件锁 (File Lock) ：确保同一时间只有一个智能体能修改某个文件。
    • 信号量 (Semaphore) ：通过创建/删除特定的“信号文件”来控制并发度（例如，最多允许3个智能体同时执行任务A）。
    • 屏障 (Barrier) ：让多个智能体在某个点同步等待，直到所有成员都就绪。
    • 操作日志 (Operation Log) ：所有文件操作都被记录，可用于调试、监控或实现事务性。

2.3 与 Git 的类比

理解 PuppyOne 的一个好方法是类比 Git ，但目的不同。

特性 Git PuppyOne
核心目标 版本控制、代码协作 实时协作、状态共享、任务协调
工作模式 提交（Commit）、拉取（Pull）、推送（Push）的异步模式 直接读写、锁控制的同步/实时模式
冲突解决 合并冲突（Merge Conflict），需要手动解决 通过锁机制预防冲突，或提供原子操作
适用场景 代码、文档的长期版本管理 AI智能体流水线、实时数据处理、多步骤任务协作

PuppyOne 更像是为智能体提供了一个 “带有 Git 式协作意识，但具备实时性”的共享文件系统 。

3. 环境准备与前置条件

接下来，我们开始实战。我们将构建一个简单的场景：一个 下载智能体 和一个 处理智能体 协作工作。下载智能体将网络图片下载到共享工作区，处理智能体监听到新文件后，对其进行压缩并归档。

3.1 系统与工具要求

  • 操作系统 ：Linux (Ubuntu 20.04+ / CentOS 7+), macOS，或 Windows (WSL2 推荐)。本文以 Linux/macOS 命令行示例为主。
  • Python ：版本 3.8 及以上。这是 PuppyOne 客户端的主要语言。
  • 包管理工具 ： pip 。
  • 代码编辑器 ：VS Code, PyCharm 等均可。

3.2 安装 PuppyOne

PuppyOne 目前主要通过 Python 包分发。安装非常简单： 

# 使用 pip 安装 puppyone 客户端库
pip install puppyone

# 如果你想从源码安装或查看示例，可以克隆仓库（非必须）
# git clone https://github.com/your-org/puppyone.git
# cd puppyone
# pip install -e .

注意 ： puppyone 包通常包含了客户端库和一个轻量级的本地服务端，用于开发和测试。生产环境可能需要部署独立服务端。

3.3 创建项目目录结构

我们创建一个清晰的项目目录来管理代码和共享工作区。 

mkdir -p puppyone_demo/{workspace,agents}
cd puppyone_demo
tree .

预期输出结构： 

.
├── agents         # 存放智能体代码
│   ├── download_agent.py
│   └── process_agent.py
└── workspace      # 共享工作区根目录（将由PuppyOne管理）

workspace 目录就是我们为智能体们准备的“共享办公室”。

4. 核心流程拆解：从启动服务到智能体协作

整个流程可以分为以下几步，我们将逐步实现：

  1. 启动 PuppyOne 服务 ：托管我们的 workspace 目录。
  2. 编写下载智能体 ：集成 PuppyOne 客户端，下载文件到共享区。
  3. 编写处理智能体 ：集成 PuppyOne 客户端，监听并处理新文件。
  4. 实现协调逻辑 ：使用文件锁确保处理时文件已就绪。
  5. 运行与验证 ：启动智能体，观察协作过程。

5. 完整示例与代码实现

5.1 启动 PuppyOne 服务

PuppyOne 服务可以以多种方式启动。最简单的是使用其内置的 CLI 工具。在项目根目录 ( puppyone_demo/ ) 下，打开一个终端窗口，运行： 

# 启动服务，指定工作区路径和端口（默认可能是 8000，请以实际文档为准）
# 假设 puppyone 提供了 `puppyone-server` 命令
puppyone-server --workspace ./workspace --port 8080

# 如果没有专用命令，也可能是一个Python模块
# python -m puppyone.server --workspace ./workspace --port 8080

服务启动后，会监听 8080 端口。我们的智能体客户端将通过这个端口与服务工作区进行交互。

关键点 ：服务启动时，会初始化工作区目录，并可能在其中创建一些用于内部管理的隐藏文件或目录（如 .puppyone ），请不要手动修改或删除它们。

5.2 编写下载智能体 ( agents/download_agent.py )

这个智能体的任务是模拟从网络下载图片到共享工作区的 downloads/ 目录下。 

# filepath: agents/download_agent.py
import time
import os
from pathlib import Path
import requests
from puppyone import WorkspaceClient

class DownloadAgent:
    def __init__(self, server_url="http://localhost:8080"):
        """
        初始化下载智能体。
        :param server_url: PuppyOne 服务端地址
        """
        # 连接到PuppyOne服务，获取共享工作区的客户端实例
        self.client = WorkspaceClient(server_url)
        # 在共享工作区内定义下载目录
        self.download_dir = Path("downloads")
        # 确保目录存在（PuppyOne客户端可能提供mkdir -p功能）
        self.client.makedirs(self.download_dir, exist_ok=True)

    def download_image(self, image_url, filename):
        """
        下载图片到共享工作区。
        使用PuppyOne客户端的原子写入功能，避免写入不完整的文件被处理智能体读取。
        """
        print(f"[DownloadAgent] 开始下载: {image_url}")
        try:
            response = requests.get(image_url, stream=True, timeout=10)
            response.raise_for_status()  # 检查HTTP错误

            # 在共享工作区内创建目标文件路径
            target_path = self.download_dir / filename

            # **关键步骤：使用PuppyOne客户端的原子写入**
            # 通常，它会先写入临时文件，然后原子性地移动到目标路径。
            # 这确保了处理智能体只会看到完整的文件。
            with self.client.open(target_path, 'wb') as f:
                for chunk in response.iter_content(chunk_size=8192):
                    if chunk:
                        f.write(chunk)

            print(f"[DownloadAgent] 下载完成: {target_path}")
            return target_path
        except Exception as e:
            print(f"[DownloadAgent] 下载失败 {image_url}: {e}")
            return None

    def run(self, image_list):
        """模拟持续下载任务"""
        for i, url in enumerate(image_list):
            file_name = f"image_{i}_{int(time.time())}.jpg"
            self.download_image(url, file_name)
            time.sleep(2)  # 模拟下载间隔

if __name__ == "__main__":
    # 示例图片URL（请替换为可用的测试URL，这里使用占位符）
    test_image_urls = [
        "https://example.com/test1.jpg", # 替换为真实URL
        "https://example.com/test2.jpg",
    ]
    agent = DownloadAgent()
    print("[DownloadAgent] 启动...")
    agent.run(test_image_urls)

代码解释 ：

  1. WorkspaceClient ：这是与 PuppyOne 服务交互的核心客户端。所有文件操作都通过它进行。
  2. client.makedirs ：在共享工作区内创建目录，类似于 os.makedirs 。
  3. client.open ：这是最重要的方法。它返回一个类似文件的对象，用于读写。PuppyOne 会在背后确保操作的协调性。以 'wb' 模式打开时，它通常会实现原子写入，防止读脏数据。
  4. 我们使用 requests 库下载图片，但写入动作是通过 self.client 完成的。

5.3 编写处理智能体 ( agents/process_agent.py )

这个智能体监听 downloads/ 目录，当有新文件出现时，对其进行压缩处理，然后移动到 processed/ 目录。 

# filepath: agents/process_agent.py
import time
from pathlib import Path
from puppyone import WorkspaceClient

class ProcessAgent:
    def __init__(self, server_url="http://localhost:8080"):
        """
        初始化处理智能体。
        """
        self.client = WorkspaceClient(server_url)
        self.download_dir = Path("downloads")
        self.processed_dir = Path("processed")
        self.client.makedirs(self.processed_dir, exist_ok=True)

    def process_file(self, file_path):
        """
        处理单个文件：模拟压缩操作。
        使用文件锁确保在处理过程中，下载智能体不会修改该文件。
        """
        print(f"[ProcessAgent] 开始处理文件: {file_path}")
        
        # **关键步骤：尝试获取文件锁**
        # 假设PuppyOne客户端提供了`lock`上下文管理器。
        # 如果获取锁失败（比如文件正在被写入），可以等待或跳过。
        try:
            # 使用锁来安全地读取文件
            with self.client.lock(file_path):
                # 读取文件内容（模拟）
                with self.client.open(file_path, 'rb') as f:
                    # 在实际应用中，这里可能是图像处理库（如PIL）的调用
                    data = f.read()
                    processed_data = self._simulate_compress(data)
                
                # 将处理后的数据写入新位置
                new_name = file_path.stem + "_compressed" + file_path.suffix
                target_path = self.processed_dir / new_name
                with self.client.open(target_path, 'wb') as f:
                    f.write(processed_data)
                
                # 可选：删除或归档原文件
                # self.client.remove(file_path)
                print(f"[ProcessAgent] 处理完成，输出至: {target_path}")
                return target_path
                
        except Exception as e:
            # 可能是锁获取超时或其他错误
            print(f"[ProcessAgent] 处理文件 {file_path} 时出错: {e}")
            return None

    def _simulate_compress(self, data):
        """模拟压缩过程（这里简单返回原数据）"""
        # 真实场景下，这里调用 cv2, PIL, 或其他处理库
        # 例如：缩小图片尺寸，降低质量等
        return data[:len(data)//2] + b"[COMPRESSED]"  # 模拟处理

    def watch_and_process(self, interval=3):
        """监视下载目录并处理新文件"""
        print(f"[ProcessAgent] 开始监视目录: {self.download_dir}")
        processed_files = set()
        
        while True:
            try:
                # 列出下载目录下的所有文件（通过PuppyOne客户端）
                all_files = list(self.client.listdir(self.download_dir))
                for file_entry in all_files:
                    file_path = self.download_dir / file_entry.name
                    # 只处理常规文件，且未处理过的
                    if file_entry.is_file() and str(file_path) not in processed_files:
                        self.process_file(file_path)
                        processed_files.add(str(file_path))
            except Exception as e:
                print(f"[ProcessAgent] 监视循环出错: {e}")
            
            time.sleep(interval)  # 每隔一段时间检查一次

if __name__ == "__main__":
    agent = ProcessAgent()
    print("[ProcessAgent] 启动...")
    agent.watch_and_process()

代码解释 ：

  1. client.lock(file_path) ：这是协调的核心。它尝试在指定文件上放置一个锁。如果下载智能体正在写入该文件（通过 client.open 的原子操作可能也隐含了锁），处理智能体会等待或抛出异常，从而避免读取不完整文件。 这是解决竞态条件的关键 。
  2. client.listdir ：列出共享工作区内目录的内容，返回的可能是包含元数据的对象列表。
  3. 处理完成后，文件被移动到 processed/ 目录，实现了简单的流水线。

5.4 协调逻辑的深化：使用信号量控制并发

上面的例子使用了文件锁。PuppyOne 可能还提供更高级的原语。例如，如果我们有多个处理智能体，但只想让最多2个同时处理文件，可以使用信号量。 

# 假设PuppyOne客户端提供了信号量支持（此处为概念代码）
from puppyone import Semaphore

def process_with_concurrency_control(self, file_path):
    # 创建一个名为“image_processing”的信号量，最大并发数为2
    semaphore = Semaphore(self.client, "image_processing", max_leases=2)
    
    # 尝试获取一个许可
    if semaphore.acquire(timeout=5):
        try:
            # 执行处理任务
            self._do_actual_processing(file_path)
        finally:
            # 释放许可
            semaphore.release()
    else:
        print(f"[ProcessAgent] 无法获取信号量许可，跳过文件 {file_path}")

6. 运行结果与效果验证

现在，让我们把整个系统跑起来，看看它们是如何协作的。

6.1 启动步骤

  1. 终端1 - 启动服务 ： 

    cd /path/to/puppyone_demo
puppyone-server --workspace ./workspace --port 8080

    看到类似 Server started on http://0.0.0.0:8080 的日志。

  2. 终端2 - 启动处理智能体 ： 

    cd /path/to/puppyone_demo
python agents/process_agent.py

    输出： [ProcessAgent] 启动... 和 [ProcessAgent] 开始监视目录: downloads

  3. 终端3 - 启动下载智能体 ： 

    cd /path/to/puppyone_demo
# 修改 download_agent.py 中的 test_image_urls 为真实的图片URL
# 例如使用一些免费的测试图片API
python agents/download_agent.py

6.2 预期输出与验证

下载智能体终端输出 ： 

[DownloadAgent] 启动...
[DownloadAgent] 开始下载: https://picsum.photos/200/300
[DownloadAgent] 下载完成: downloads/image_0_1712345678.jpg
[DownloadAgent] 开始下载: https://picsum.photos/200/301
[DownloadAgent] 下载完成: downloads/image_1_1712345680.jpg

处理智能体终端输出 ： 

[ProcessAgent] 启动...
[ProcessAgent] 开始监视目录: downloads
[ProcessAgent] 开始处理文件: downloads/image_0_1712345678.jpg
[ProcessAgent] 处理完成，输出至: processed/image_0_1712345678_compressed.jpg
[ProcessAgent] 开始处理文件: downloads/image_1_1712345680.jpg
[ProcessAgent] 处理完成，输出至: processed/image_1_1712345680_compressed.jpg

文件系统验证 ： 在项目目录下，使用 tree 命令或直接查看 workspace 文件夹： 

tree workspace/

预期看到类似结构： 

workspace/
├── .puppyone          # PuppyOne内部管理目录（可能）
├── downloads
│   ├── image_0_1712345678.jpg      # 可能已被处理智能体删除或保留
│   └── image_1_1712345680.jpg
└── processed
    ├── image_0_1712345678_compressed.jpg
    └── image_1_1712345680_compressed.jpg

如何判断成功 ：

  1. 两个智能体进程正常运行，无报错崩溃。
  2. 文件从 downloads 流向 processed 目录。
  3. 即使同时运行多个下载或处理智能体，也没有出现“文件未找到”、“权限错误”或处理了半截文件等典型并发问题。
  4. 查看 PuppyOne 服务端日志（如果提供），可以看到文件锁的获取/释放记录。

7. 常见问题与排查思路

在实际部署中，你可能会遇到以下问题：

问题现象 可能原因 排查方式 解决方案
智能体无法连接服务端 1. 服务端未启动。
2. 端口被占用或防火墙阻止。
3. server_url 配置错误。 		1. 检查服务端进程是否运行 ( ps aux | grep puppyone )。
2. 用 curl http://localhost:8080/health (假设有健康检查端点) 测试连通性。
3. 检查客户端代码中的 server_url 。 		1. 确保先启动服务端。
2. 更换端口或配置防火墙规则。
3. 使用正确的IP和端口。
文件操作权限被拒绝 1. PuppyOne 服务进程对 workspace 目录无写权限。
2. 客户端尝试访问工作区外的路径。 		1. 检查 workspace 目录的权限 ( ls -ld workspace )。
2. 查看服务端日志中的权限错误。 		1. 确保服务端运行用户对该目录有 rwx 权限。
2. 客户端只使用相对路径，不要使用绝对路径或 ../ 跳出工作区。
处理智能体读到空文件或损坏文件 1. 未使用 PuppyOne 客户端的原子写或锁机制。
2. 下载智能体写入过程中发生异常中断。 		1. 检查下载智能体是否使用 client.open() 写入。
2. 在处理智能体中添加文件锁，并检查文件大小/校验和。 		1. 强制使用 client.open() 进行所有文件操作，避免直接使用 open() 。
2. 在处理前，使用锁确保文件已关闭。可以考虑使用“写完成标志文件”（如 .done 文件）的机制。
多个处理智能体同时处理同一个文件 文件锁未生效或逻辑有误。 1. 检查 client.lock() 调用是否正确，是否在 try-except 中。
2. 查看服务端是否支持锁，以及锁的粒度（文件级、目录级）。 		1. 确保锁的获取和释放成对出现，使用 with 语句管理锁资源。
2. 如果PuppyOne锁不可用，可在应用层实现基于文件的锁（如创建 .lock 文件）。
性能瓶颈 1. 网络延迟（如果服务端远程）。
2. 文件锁竞争激烈。
3. 频繁列出目录 ( listdir )。 		1. 监控服务端和客户端的CPU、内存、网络IO。
2. 分析日志，看时间消耗在哪个操作。 		1. 对于本地智能体，使用本地或Unix域套接字模式。
2. 优化锁粒度，减少锁持有时间。
3. 使用事件通知（如inotify）替代轮询 listdir ，如果PuppyOne支持。

8. 最佳实践与工程建议

将 PuppyOne 用于生产环境的多智能体系统时，请考虑以下建议：

  1. 工作区命名规范 ：为不同的项目或任务流水线创建不同的工作区根目录，避免交叉污染。例如 /workspaces/project_a/ , /workspaces/project_b/ 。

  2. 错误处理与重试 ：网络和文件操作可能失败。在所有客户端操作周围添加健壮的错误处理和指数退避重试逻辑。 

    import time
from tenacity import retry, stop_after_attempt, wait_exponential

@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, min=1, max=10))
def safe_write_with_puppyone(client, path, data):
    with client.open(path, 'wb') as f:
        f.write(data)

  3. 监控与可观测性 ：

    • 日志 ：在智能体和服务端记录关键操作（文件创建、锁获取/释放、错误）。
    • 指标 ：考虑暴露指标，如文件操作延迟、锁等待时间、工作区容量，集成到 Prometheus/Grafana。
    • 审计 ：利用 PuppyOne 的操作日志，追踪“谁在什么时候做了什么”。

  4. 安全边界 ：

    • 隔离 ：确保 PuppyOne 服务端运行在独立的、权限受限的用户下。
    • 路径穿越防护 ：客户端应只允许操作工作区内的相对路径。服务端必须严格校验路径，防止 ../../../etc/passwd 这类攻击。
    • 认证与授权（如果支持） ：如果服务端暴露在网络上，应配置认证机制，并为不同智能体分配不同的访问权限（如只读、只写特定目录）。

  5. 与现有智能体框架集成 ：PuppyOne 是协作层，不是执行层。你可以轻松地将它集成到 LangGraph 的状态（State）中，或者作为 AutoGen 智能体的一个工具（Tool）。核心是将 WorkspaceClient 实例作为智能体上下文的一部分进行传递。

  6. 备份与持久化 ：共享工作区是任务关键状态。定期备份重要数据。考虑将最终结果同步到更持久的存储（如 S3、数据库）中，工作区本身主要作为“暂存区”。

  7. 测试策略 ：

    • 单元测试 ：模拟 WorkspaceClient ，测试智能体的业务逻辑。
    • 集成测试 ：启动真实的 PuppyOne 服务，测试多个智能体的协作流程。
    • 混沌测试 ：模拟网络分区、服务端重启、智能体崩溃，验证系统的鲁棒性。

9. 总结与后续学习方向

通过本文的实践，我们完成了从概念到落地的全过程。PuppyOne 提出的“文件系统即共享工作区”模式，其价值在于 将复杂的分布式协调问题，抽象为熟悉的文件操作问题 。开发者无需深入研究分布式锁、消息队列的细节，就能快速构建出协作有序的多智能体应用。

本文的核心结论 ：

  1. PuppyOne 的本质 ：是一个为 AI 智能体设计的 文件系统协调中间件 ，它通过封装文件操作并注入锁、信号量等原语，来预防冲突和协调任务。
  2. 最适合的场景 ：涉及文件流转、多步骤流水线、需要共享中间状态的多智能体系统。例如：文档处理流水线、多模态AI应用（文本->图像->审核）、数据ETL任务等。
  3. 关键实践 ：务必使用 PuppyOne 客户端提供的 open() , lock() 等方法进行所有文件操作，这是保证一致性的基础。

下一步你可以探索 ：

  1. 深入研究高级原语 ：探索 PuppyOne 是否支持屏障（Barrier）、队列（Queue）等更复杂的协调模式。
  2. 分布式部署 ：将 PuppyOne 服务端部署为独立的集群，让运行在不同机器上的智能体也能协作。
  3. 与云存储集成 ：研究 PuppyOne 是否能将 S3、Azure Blob 等对象存储抽象为“共享工作区”，实现跨云协作。
  4. 性能压测 ：在你的具体业务场景下，测试多智能体高并发操作文件时的性能表现，找到瓶颈并优化。

最后的提醒 ：PuppyOne 是一个新兴项目，其 API 和功能可能快速迭代。在实际生产应用前，请务必仔细阅读其官方文档，测试其稳定性和功能是否符合你的需求。建议收藏本文，作为理解其核心模式和入门实践的参考。当你需要为你的智能体团队找一个“共享办公室”时，PuppyOne 无疑提供了一个极具启发性的解决方案。

# AI智能体 # 文件系统
Logo
码道开发者社区

码道开发者社区，聚焦华为云码道 CodeArts 代码智能体，沉淀 Agent、Skill、鸿蒙开发实战内容，供开发者查阅资料、交流技术、分享工程实践

更多推荐

cover

状态丢失排障：Claude 持久记忆的跨会话局限与知芽 Notebook Skill 单元记忆如何沉淀可复用知识资产

avatar 码道开发者社区
cover

vs code 下载安装 以及 如何配置 claude code 和codex

avatar 码道开发者社区
cover

GitHub不再让一个模型写到底：HydraFusion多模型编排，官方评测成本降低67%

avatar 码道开发者社区