AutoDL 云服务器上安装 Kimi Code + NanoBot 并配置 GPU 使用完整教程
环境说明：PyTorch 2.8.0 / Python 3.12 / Ubuntu 22.04 / CUDA 12.8
目标：在 AutoDL 云服务器上安装 Kimi Code 和 NanoBot，并让 Kimi Code 帮我们"教会" NanoBot 使用服务器上的 GPU，实现一个 AI Agent 能自主调用 GPU 干活。
本博客全部操作流程均由 DeepSeek V4 与 Kimi Code 全程辅助完成
一、前言
最近发现了一个非常有趣的玩法：在 AutoDL 云服务器上安装 Kimi Code ，然后让 Kimi Code 帮我们管理和优化 NanoBot。这样一来，我们只需要把需求丢给 Kimi Code，它自己就能在服务器上干活，包括配置 GPU、写代码、跑实验，完全不用我们手动折腾。
这篇博客会完整记录整个过程，包括：
- Kimi Code 的安装与登录
- NanoBot 的安装与初始化
- 配置 DeepSeek API
- 让 Kimi Code 教会 NanoBot 使用 GPU
- 最终验证
二、环境信息
| 项目 | 配置 |
|---|---|
| 云平台 | AutoDL |
| 镜像 | PyTorch 2.8.0 |
| Python | 3.12 |
| 系统 | Ubuntu 22.04 |
| CUDA | 12.8 |
| GPU | NVIDIA GeForce RTX 4080 SUPER (32GB) |
三、安装 Kimi Code
Kimi Code 是 Kimi 推出的命令行 AI 编程助手，安装教程可以参考官网：
👉 https://www.kimi.com/code/docs/
3.1 添加 PATH（关键前置步骤）
在 Linux 环境下安装前，必须先执行以下命令，否则后续会报错：
bash
export PATH="$HOME/.local/bin:$PATH"⚠️ 如果不做这一步，直接运行安装脚本会报错
uv not found after installation：
bash
root@autodl-container-1b714b8fee-a95fb261:~# curl -LsSf https://code.kimi.com/install.sh | bash
downloading uv 0.11.7 x86_64-unknown-linux-gnu
installing to /root/.local/bin
uv
uvx
everything's installed!
To add $HOME/.local/bin to your PATH, either restart your shell or run:
source $HOME/.local/bin/env (sh, bash, zsh)
source $HOME/.local/bin/env.fish (fish)
Error: uv not found after installation.3.2 执行安装命令
bash
curl -LsSf https://code.kimi.com/install.sh | bash
安装完成后，在终端直接输入：
bash
kimi
3.3 登录 Kimi Code
在 Kimi Code 交互界面中输入：
bash
/login
选择 Kimi Code （输入 1）：
bash
1. Kimi Code
点击终端中出现的链接，跳转到网页完成登录：
登录成功后，Kimi Code 就可以正常使用了！
四、安装 NanoBot
NanoBot 是一个开源的 AI Agent 框架，GitHub 地址：
👉 https://github.com/HKUDS/nanobot
安装部署指南可以参考：
👉 NanoBot 安装部署完全指南：从零开始配置你的 AI 助手
4.1 使用 uv 安装 NanoBot
bash
uv tool install nanobot-ai
4.2 初始化 NanoBot
bash
nanobot onboard初始化成功后，会显示如下输出：
bash
root@autodl-container-1b714b8fee-a95fb261:~# nanobot onboard
✓ Created config at /root/.nanobot/config.json
2026-04-26 13:34:39.062 | DEBUG | nanobot.channels.registry:discover_all:64 - Skipping built-in channel 'matrix': Matrix dependencies not installed. Run: pip install nanobot-ai[matrix]
Created AGENTS.md
Created HEARTBEAT.md
Created SOUL.md
Created TOOLS.md
Created USER.md
Created memory/MEMORY.md
Created memory/history.jsonl
2026-04-26 13:34:41.331 | INFO | nanobot.utils.gitstore:init:113 - Git store initialized at /root/.nanobot/workspace
🐈 nanobot is ready!
Next steps:
1. Add your API key to /root/.nanobot/config.json
Get one at: https://openrouter.ai/keys
2. Chat: nanobot agent -m "Hello!" --config /root/.nanobot/config.json
Want Telegram/WhatsApp? See: https://github.com/HKUDS/nanobot#-chat-apps
NanoBot 的安装路径在 /root/.nanobot/，后续所有配置都在这个目录下。
五、配置 DeepSeek API
NanoBot 需要配置 LLM API 才能工作，这里我们使用 DeepSeek 的 API。
5.1 打开配置文件
在 AutoDL 上可以通过以下方式打开 /root/.nanobot/config.json：
方式一 ：文件 → 从路径打开，然后输入 /root/.nanobot/config.json
如果"从路径打开"不成功，可以用方式二。
方式二：先把文件复制到根目录，修改后再替换回去。
bash
cp /root/.nanobot/config.json /root/5.2 修改配置
修改后的配置内容如下（重点关注 agents.defaults 和 providers.openai 部分）：
json
{
"agents": {
"defaults": {
"workspace": "~/.nanobot/workspace",
"model": "deepseek-v4-pro",
"provider": "openai",
"maxTokens": 8192,
"contextWindowTokens": 65536,
"contextBlockLimit": null,
"temperature": 0.1,
"maxToolIterations": 200,
"maxToolResultChars": 16000,
"providerRetryMode": "standard",
"reasoningEffort": null,
"timezone": "UTC",
"unifiedSession": false,
"disabledSkills": [],
"idleCompactAfterMinutes": 0,
"dream": {
"intervalH": 2,
"modelOverride": null,
"maxBatchSize": 20,
"maxIterations": 15,
"annotateLineAges": true
}
}
},
在 providers 部分添加 DeepSeek 的 API 配置：
json
"openai": {
"apiKey": "sk-你的DeepSeek API密钥",
"apiBase": "https://api.deepseek.com/v1",
"extraHeaders": null
},
💡 获取 API Key ：前往 https://openrouter.ai/keys 或 DeepSeek 官方获取。
5.3 保存配置
如果用方式二复制的文件，修改完成后复制回原来路径：
bash
cp /root/config.json /root/.nanobot/config.json六、启动 NanoBot
配置完成后，启动 NanoBot 进入交互模式：
bash
nanobot agent
到这里，NanoBot 已经在 AutoDL 上成功运行了！
七、让 Kimi Code 教会 NanoBot 使用 GPU（核心步骤）
这是整个教程最精彩的部分------让 Kimi Code 来帮我们优化和配置 NanoBot。
7.1 启动 Kimi Code
bash
kimi7.2 给 Kimi Code 下任务
输入以下提示词，告诉 Kimi Code 当前环境和需求：
我现在需要你帮养"nanobot"，我先给你说说你（kimi code）和nanobot所在环境：
当前环境在AutoDL云服务器上，环境是：PyTorch / 2.8.0 / 3.12(ubuntu22.04) / 12.8
nanobot的路径在：/root/.nanobot
nanobot的项目github：https://github.com/HKUDS/nanobot
然后这里有一块GPU，你试试可以调用这个GPU不？然后你教会nanobot来使用GPU。你需要告诉我如何教会nanobot使用GPU的。7.3 Kimi Code 的自动处理过程（完整记录）
Kimi Code 收到任务后，开始自主分析并执行操作。下面是完整的处理过程：
bash
root@autodl-container-c904489327-a588448e:~# kimi
╭────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ │
│ ▐█▛█▛█▌ Welcome to Kimi Code CLI! │
│ ▐█████▌ Send /help for help information. │
│ │
│ Directory: ~ │
│ Session: b50b72bb-43a3-400a-92c6-0223a8e01279 │
│ Model: Kimi-k2.6 │
│ │
│ Tip: Spot a bug or have feedback? Type /feedback right in this session --- every report makes Kimi better. │
│ │
╰────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✨ 我现在需要你帮养"nanobot"，我先给你说说你（kimi code）和nanobot所在环境：
当前环境在AutoDL云服务器上，环境是：PyTorch / 2.8.0 / 3.12(ubuntu22.04) / 12.8
nanobot的路径在：/root/.nanobot
nanobot的项目github：https://github.com/HKUDS/nanobot
然后这里有一块GPU，你试试可以调用这个GPU不？然后你教会nanobot来使用GPU。你需要告诉我如何教会nanobot使用GPU的。
• 用户需要我：
1. 检查当前环境中的GPU是否可用
2. 查看nanobot项目（在/root/.nanobot）
3. 教会nanobot使用GPU
4. 告诉用户我是如何做的
让我先了解nanobot是什么，以及检查GPU情况。
• Used Shell (nvidia-smi)
• Used Shell (cat /root/.nanobot/config.json)
• Used Shell (ls -la /root/.nanobot/)
• 首先，让我了解nanobot是什么项目。用户提到了GitHub地址：https://github.com/HKUDS/nanobot。让我先了解一下nanobot项目的详情，以及它的GPU使用情况。
当前环境：
• GPU: NVIDIA GeForce RTX 4080 SUPER, 32GB显存
• CUDA Version: 13.0
• PyTorch 2.8.0
• Python 3.12
nanobot在/root/.nanobot，但看起来这里主要是配置目录。我需要看看workspace里面有什么，以及nanobot是否有其他安装位置或者代码仓库。
让我先搜索一下nanobot的安装位置，以及它是否支持GPU。
• Used Shell (which nanobot 2>/dev/null... f 2>/dev/null | head -20)
• Used Shell (ls -la /root/.nanobot/workspace/)
• Used Shell (pip show nanobot 2>/dev/n...not found as pip package")
• Used Shell (python -c "import torch; ...available() else None}')")
• 好的，让我继续了解nanobot。它似乎是一个可执行文件在/root/.local/bin/nanobot。我需要看看它是什么类型的文件，以及它的来源。
用户说nanobot的GitHub是：https://github.com/HKUDS/nanobot
我需要：
1. 了解nanobot是什么，是否支持GPU
2. 检查nanobot的代码结构
3. 看看它是否有使用GPU的功能
让我先看看nanobot可执行文件是什么，以及是否有源码安装。
• Used Shell (file /root/.local/bin/nanobot)
• Used Shell (ls -la /root/.local/bin/nanobot)
• Used Shell (head -c 2000 /root/.local/bin/nanobot)
• Used Shell (find / -path "*/nanobot*"... d 2>/dev/null | head -20)
• 好的，nanobot是一个通过uv安装的Python包。让我深入了解nanobot的代码，看看它是否已经有GPU支持，或者是否需要配置。
让我先看看nanobot的源码结构。
• Used Shell (ls -la /root/.local/share...13/site-packages/nanobot/)
• Used Shell (cat /root/.nanobot/workspace/AGENTS.md)
• Used Shell (cat /root/.nanobot/workspace/TOOLS.md)
• Used Shell (cat /root/.nanobot/workspace/SOUL.md)
• 让我继续了解nanobot的代码，特别是skills目录，因为用户说需要"教会"nanobot使用GPU。我需要看看nanobot是否已经有相关的skill，或者它是否支持自定义skill。
让我看看skills目录和agent目录。
• Used Shell (ls -la /root/.local/share...-packages/nanobot/skills/)
• Used Shell (ls -la /root/.nanobot/workspace/skills/)
• Used Shell (cat /root/.local/share/uv...anobot/skills/__init__.py)
Failed with exit code: 1
• Used Shell (find /root/.local/share/u...epth 1 -type d | head -20)
• 让我继续查看nanobot的skill结构和README，了解如何创建自定义skill。
• Used Shell (cat /root/.local/share/uv.../nanobot/skills/README.md)
• Used Shell (ls -la /root/.local/share...bot/skills/skill-creator/)
• Used Shell (cat /root/.local/share/uv...ls/skill-creator/SKILL.md)
• 现在我对nanobot有了较好的理解。nanobot是一个AI agent框架，它通过skills来扩展能力。用户的请求是"教会nanobot使用GPU"。
我需要理解用户所说的"教会nanobot使用GPU"是什么意思。nanobot本身是一个LLM agent框架，它不直接运行深度学习模型，而是调用工具（包括exec来运行命令）。但是，用户可能希望：
1. nanobot能够感知到GPU的存在，并在需要时利用GPU（比如运行PyTorch代码、训练模型等）
2. 创建一个skill，让nanobot知道如何在当前环境中使用GPU
让我先看看nanobot当前的配置和工具设置，特别是exec工具的配置。从config.json中可以看到：
"exec": {
"enable": true,
"timeout": 60,
"pathAppend": "",
"sandbox": "",
"allowedEnvKeys": []
}
GPU在PyTorch中已经是可用的：
• PyTorch 2.8.0+cu128
• CUDA available: True
• GPU: NVIDIA GeForce RTX 4080 SUPER
所以问题可能是：
1. nanobot运行在一个隔离的Python环境中（uv tools environment, Python 3.13），而PyTorch是安装在系统环境（miniconda3, Python 3.12）中的
2. nanobot的exec工具可能无法访问到正确的CUDA和PyTorch环境
让我检查一下nanobot运行时使用的Python环境，以及系统Python环境的情况。
• Used Shell (/root/.local/share/uv/too...Torch not in nanobot env")
• Used Shell (which python && python --version)
• Used Shell (conda info --envs 2>/dev/null || echo "no conda")
• Used Shell (python -c "import torch; ...available() else None}')")
• 现在我理解了问题所在：
1. nanobot运行在自己的uv隔离环境中（Python 3.13），这个环境里没有PyTorch，也没有CUDA支持。
2. 系统上有一个conda base环境（Python 3.12），里面安装了PyTorch 2.8.0+cu128，可以正常使用GPU。
3. 当nanobot使用exec工具执行命令时，它默认使用的是nanobot自己的Python环境，无法访问到PyTorch和GPU。
要"教会nanobot使用GPU"，我需要：
1. 让nanobot的exec工具能够访问到正确的conda环境（或者让nanobot的Python环境也能使用GPU）
2. 创建一个skill，告诉nanobot关于GPU的信息，以及如何在当前环境中使用它
有几种方案：
1. 在nanobot的uv环境中安装PyTorch - 这样nanobot自己就能import torch。但是uv环境是Python 3.13，而PyTorch 2.8.0+cu128是为Python 3.12安装的。
2. 配置nanobot的exec工具，使其使用conda环境的Python - 修改pathAppend或者设置环境变量，让exec调用时能找到conda的python和torch。
3. 创建一个GPU skill - 让nanobot知道GPU的存在，以及在执行涉及GPU的任务时使用conda环境。
让我先检查uv能否给nanobot环境安装torch，或者是否可以通过conda来激活环境。
实际上最简单的方法可能是：
• 让nanobot的exec工具默认使用 /root/miniconda3/bin/python 而不是它自己的python
• 或者在config.json中设置 pathAppend 包含conda路径
• 或者创建一个skill，告诉nanobot在执行涉及GPU的代码时，使用完整路径 /root/miniconda3/bin/python
让我看看nanobot exec工具的实现，了解它是如何执行命令的。
• Used Shell (cat /root/.local/share/uv...init_skill.py | head -100)
• Used Shell (grep -r "exec" /root/.loc...l\|class\|def" | head -20)
• Used Shell (find /root/.local/share/u...exec\|sandbox" | head -10)
• 让我查看nanobot的exec工具具体实现，特别是它如何执行命令和环境变量设置。
• Used Shell (find /root/.local/share/u...ool\|def exec" | head -10)
• Used Shell (grep -r "ExecTool\|exec_t...ools/ --include="*.py" -l)
• 让我查看shell.py中exec工具的实现。
• Used ReadFile (.local/share/uv/tools/nan...obot/agent/tools/shell.py)
• 现在我理解了nanobot的exec工具是如何工作的：
1. 在Linux上，它使用 bash -l -c 来执行命令
2. 环境变量只传递 HOME, LANG, TERM，以及 allowed_env_keys 中指定的环境变量
3. bash -l 会加载用户的profile（.bashrc, .profile等），所以PATH等变量会在shell启动时从profile中加载
4. path_append 会在命令前添加 export PATH="$PATH:...
所以nanobot执行命令时，理论上可以访问到系统的conda环境（因为.bashrc通常会配置conda）。
让我测试一下nanobot执行命令时能否访问到GPU相关的工具。
• Used Shell (bash -l -c "which python ...ch.cuda.is_available())'")
• Used Shell (cat /root/.bashrc | grep ...da\|miniconda" | head -30)
• Used Shell (bash -l -c 'echo $PATH')
• 好的，bash -l 环境下可以正确访问conda的python和torch.cuda。所以nanobot的exec工具实际上已经可以调用GPU了，因为exec工具使用bash -l -c来执行命令。
但是问题在于：
1. nanobot自己（它的Python进程）运行在uv的隔离环境中，无法import torch
2. nanobot的exec工具通过bash -l -c执行命令时，实际上可以访问conda环境的python和torch
所以如果用户想要nanobot"使用GPU"，可能需要：
1. 让nanobot知道GPU的存在，这样它在回答相关问题时能利用GPU
2. 创建一个skill，告诉nanobot当前环境有GPU，以及如何在exec中调用GPU相关的工具
让我再检查一下nanobot是否有其他方式来直接运行Python代码（而不是通过shell exec）。
• Used Shell (grep -r "python\|python3"...include="*.py" | head -20)
• Used Shell (cat /root/.nanobot/workspace/USER.md)
• Used Shell (cat /root/.nanobot/workspace/HEARTBEAT.md)
• 让我整理一下目前的发现：
1. GPU可用性：系统上有一块NVIDIA RTX 4080 SUPER (32GB)，CUDA 12.8，PyTorch 2.8.0+cu128已经安装在conda base环境（Python 3.12）中，可以正常使用GPU。
2. nanobot的环境问题：
• nanobot本身运行在uv隔离环境中（Python 3.13），这个环境里没有PyTorch
• 但是nanobot的exec工具使用bash -l -c执行命令，会加载用户profile，所以exec中可以访问conda环境的python和torch
3. 如何"教会"nanobot使用GPU： 用户所说的"教会"，在nanobot的语境下，最合理的解释是创建一个skill，让nanobot知道：
• 当前环境有GPU
• GPU的规格和CUDA版本
• 如何在当前环境中调用GPU（使用conda base环境的python，而不是nanobot自己的python）
然后还需要确保nanobot的exec配置正确，让GPU环境变量（如CUDA_VISIBLE_DEVICES等）可以传递。
让我再看看nanobot的notebook工具，因为它提到了python kernel，看看是否有相关的配置。
• Used ReadFile (.local/share/uv/tools/nan...t/agent/tools/notebook.py)
• Used Shell (grep -r "kernel\|jupyter\...include="*.py" | head -20)
• 现在我有了完整的理解。让我总结：
nanobot使用GPU的能力现状：
• nanobot的exec工具使用bash -l -c执行命令，会自动加载用户profile，所以可以访问conda环境中的python和pytorch
• 但nanobot自己运行的uv环境（Python 3.13）没有安装PyTorch
"教会"nanobot使用GPU的最佳方式：
1. 创建一个gpu skill，包含：
• 当前环境的GPU信息（RTX 4080 SUPER, 32GB, CUDA 12.8）
• PyTorch安装位置（conda base环境, Python 3.12）
• 告诉nanobot在执行涉及GPU的Python代码时，使用/root/miniconda3/bin/python而不是默认的python
2. 确保exec工具的环境变量配置正确：
• allowedEnvKeys应该包含CUDA相关的环境变量（如CUDA_VISIBLE_DEVICES, CUDA_HOME等）
• pathAppend应该包含conda和cuda的路径
让我先测试一下nanobot exec环境下nvidia-smi和python torch的可用性。
• Used Shell (bash -l -c "nvidia-smi --...ailable() else None}\")'")
Failed with exit code: 2
• Used Shell (echo $CUDA_HOME && ls -la...ocal/cuda/bin/ | head -10)
• Used Shell (cat /root/.local/share/uv...py | grep -A20 "def main")
• 让我继续执行。我需要：
1. 创建一个gpu skill
2. 配置nanobot的config.json，确保GPU环境变量可以传递
让我先检查当前config.json中allowedEnvKeys是否为空，然后添加CUDA相关的环境变量。
让我也检查一下/usr/local/cuda是否存在以及CUDA_HOME的情况。
• Used Shell (ls -la /usr/local/cuda &&...| echo "no cuda-12.8 dir")
• Used Shell (bash -l -c 'echo $CUDA_HO...E; echo $LD_LIBRARY_PATH')
• Used Shell (cat /etc/environment 2>/d...cho "no /etc/environment")
• 我现在需要做的：
1. 创建gpu skill - 让nanobot知道环境中有GPU，以及如何使用
2. 更新config.json - 添加GPU相关的环境变量到allowedEnvKeys，这样exec子进程可以继承这些变量
3. 可能需要更新USER.md - 添加一些关于GPU环境的信息
让我先用init_skill.py创建skill，然后手动编辑。
实际上，我可以直接手动创建skill目录和文件，这样更快捷。
另外，我还需要确认bash -l是否能正确加载conda环境。让我测试一下。
• Used Shell (bash -l -c 'echo $CONDA_D...NDA_PREFIX; which python')
• Used Shell (bash -l -c '/root/minicon...cuda.get_device_name(0))")
Failed with exit code: 2
• Used Shell (bash -l -c 'nvidia-smi --...on --format=csv,noheader')
• 引号问题，让我修复。
• Used Shell (bash -l -c "/root/minicon...uda.get_device_name(0))'")
• 现在我已经确认了：
1. bash -l 环境下可以访问conda python和torch
2. GPU是RTX 4080 SUPER，32GB显存，驱动580.76.05
3. PyTorch 2.8.0+cu128，CUDA可用
接下来我需要：
1. 创建一个 gpu skill，放在 /root/.nanobot/workspace/skills/gpu/
2. 更新 config.json，添加 allowedEnvKeys 包含 CUDA 相关环境变量
3. 可能需要更新 USER.md 添加GPU环境信息
让我开始创建skill和更新配置。
对于skill，我需要创建：
• /root/.nanobot/workspace/skills/gpu/SKILL.md
内容应该包括：
• 环境GPU信息
• 告诉nanobot在执行GPU相关任务时使用conda python
• 提供torch版本和CUDA版本信息
对于config.json更新：
• tools.exec.allowedEnvKeys 添加 CUDA_VISIBLE_DEVICES, CUDA_HOME, LD_LIBRARY_PATH, CONDA_DEFAULT_ENV 等
• tools.exec.pathAppend 添加 /usr/local/cuda/bin:/root/miniconda3/bin
让我直接操作。
• Used Shell (mkdir -p /root/.nanobot/workspace/skills/gpu)
• Used WriteFile (.nanobot/workspace/skills/gpu/SKILL.md)
╭─ +50 /root/.nanobot/workspace/skills/gpu/SKILL.md ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ 1 + --- │
│ 2 + name: gpu │
│ 3 + description: GPU computing on AutoDL with NVIDIA RTX 4080 SUPER. Use when the user asks about GPU, CUDA, PyTorch, deep learning, model training/inference, or any t... │
│ 4 + --- │
│ 5 + │
│ 6 + # GPU Environment │
│ 7 + │
│ 8 + This skill describes the local GPU environment available to nanobot. │
│ 9 + │
│ 10 + ## Hardware │
│ 11 + │
│ 12 + - **GPU**: NVIDIA GeForce RTX 4080 SUPER │
│ 13 + - **VRAM**: 32 GB (32760 MiB) │
│ 14 + - **Driver**: 580.76.05 │
│ 15 + - **CUDA Version**: 12.8 │
│ 16 + │
│ 17 + ## Software Stack │
│ 18 + │
│ 19 + - **PyTorch**: 2.8.0+cu128 (installed in conda base environment) │
│ 20 + - **Python (with GPU support)**: /root/miniconda3/bin/python (Python 3.12.3) │
│ 21 + - **CUDA Toolkit**: /usr/local/cuda (symlink to CUDA 12.8) │
│ 22 + - **Conda**: /root/miniconda3 (base environment) │
│ 23 + │
│ 24 + ## Critical Usage Rules │
│ 25 + │
│ 26 + 1. **Always use `/root/miniconda3/bin/python` for GPU tasks** │
│ 27 + - nanobot runs in its own uv-isolated Python 3.13 environment which does NOT have PyTorch or CUDA support. │
│ 28 + - The conda base environment has PyTorch 2.8.0+cu128 and full GPU support. │
│ 29 + - When writing or running Python scripts that need GPU, explicitly invoke them with `/root/miniconda3/bin/python script.py`. │
│ 30 + │
│ 31 + 2. **When running shell commands with exec:** │
│ 32 + - `bash -l` automatically loads conda into PATH, so `python` inside exec usually resolves to `/root/miniconda3/bin/python`. │
│ 33 + - But to be safe, always use the full path `/root/miniconda3/bin/python` for GPU-dependent code. │
│ 34 + │
│ 35 + 3. **Common verification commands:** │
│ 36 + ```bash │
│ 37 + /root/miniconda3/bin/python -c "import torch; print(torch.cuda.is_available()); print(torch.cuda.get_device_name(0))" │
│ 38 + nvidia-smi │
│ 39 + ``` │
│ 40 + │
│ 41 + 4. **Environment variables preserved in exec:** │
│ 42 + - `CUDA_VISIBLE_DEVICES`, `CUDA_HOME`, `LD_LIBRARY_PATH`, `CONDA_PREFIX`, `CONDA_DEFAULT_ENV` │
│ 43 + - These are forwarded to subprocesses via `tools.exec.allowedEnvKeys` in config.json. │
│ 44 + │
│ 45 + ## Typical Workflows │
│ 46 + │
│ 47 + - **Run a PyTorch script**: `/root/miniconda3/bin/python my_script.py` │
│ 48 + - **Install GPU packages**: `/root/miniconda3/bin/pip install ...` or `conda install ...` │
│ 49 + - **Check GPU status**: `nvidia-smi` │
│ 50 + - **Jupyter with GPU**: Use `/root/miniconda3/bin/python -m jupyter ...` if needed │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
• Used StrReplaceFile (.nanobot/config.json)
╭─ +2 -2 /root/.nanobot/config.json ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ 387 "exec": { │
│ 388 "enable": true, │
│ 389 "timeout": 60, │
│ 390 - "pathAppend": "", │
│ 390 + "pathAppend": "/usr/local/cuda/bin:/root/miniconda3/bin", │
│ 391 "sandbox": "", │
│ 392 - "allowedEnvKeys": [] │
│ 392 + "allowedEnvKeys": ["CUDA_VISIBLE_DEVICES", "CUDA_HOME", "LD_LIBRARY_PATH", "CONDA_PREFIX", "CONDA_DEFAULT_ENV", "CONDA_SHLVL", "PATH"] │
│ 393 }, │
│ 394 "my": { │
│ 395 "enable": true, │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
• 好的，我已经创建了gpu skill并更新了config.json。现在让我验证一下配置是否正确，然后测试一下nanobot是否能正确使用GPU。
我还需要：
1. 验证config.json的JSON格式正确
2. 确保skill能被nanobot识别
3. 可能需要更新USER.md，添加GPU相关的工具使用信息
4. 重启nanobot使配置生效（如果需要）
让我先验证JSON格式和skill结构。
• Used Shell (python -m json.tool /root...onfig.json is valid JSON")
• Used Shell (ls -la /root/.nanobot/workspace/skills/gpu/)
• Used Shell (cat /root/.nanobot/config...json | grep -A10 '"exec"')
• 现在让我再验证一下nanobot的skill是否被正确加载。我需要检查nanobot的日志或者启动nanobot看看是否能识别新skill。
另外，我还需要检查nanobot是否正在运行，以及如何重启它。
• Used Shell (ps aux | grep nanobot | grep -v grep)
Failed with exit code: 1
• Used Shell (cat /root/.nanobot/workspace/AGENTS.md)
• Used Shell (cat /root/.nanobot/workspace/USER.md)
• nanobot当前没有在运行。让我更新USER.md添加一些GPU环境信息，然后验证整个配置。
我还应该测试一下skill是否能被nanobot识别。不过因为nanobot没在运行，我可以直接检查skill文件结构是否正确。
让我也确保config.json的其他部分没有问题，特别是channels和providers。
我还需要考虑一个问题：config.json中有一些敏感的API key（deepseek的api key）。我应该在回复中提醒用户注意安全。
现在让我确认一下我的改动是否完整：
1. ✅ 创建了 /root/.nanobot/workspace/skills/gpu/SKILL.md
2. ✅ 更新了 config.json：
• tools.exec.pathAppend 添加了 /usr/local/cuda/bin:/root/miniconda3/bin
• tools.exec.allowedEnvKeys 添加了GPU相关的环境变量
我还需要： 3. 更新 USER.md，在Work Context或Tools中添加GPU信息（可选但推荐）
让我完成这些。
• Used StrReplaceFile (.nanobot/workspace/USER.md)
╭─ +1 /root/.nanobot/workspace/USER.md ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ 33 - **Primary Role**: (your role, e.g., developer, researcher) │
│ 34 - **Main Projects**: (what you're working on) │
│ 35 - **Tools You Use**: (IDEs, languages, frameworks) │
│ 36 + - **GPU Environment**: NVIDIA RTX 4080 SUPER (32GB), CUDA 12.8, PyTorch 2.8.0+cu128 in /root/miniconda3 │
│ 37 │
│ 38 ## Topics of Interest │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
• 现在让我验证最终的配置，并给出一个完整的总结。我还应该提醒用户关于config.json中暴露的API key安全问题。
让我检查一下config.json中的api key。
• Used Shell (grep -n "apiKey" /root/.n...bot/config.json | head -5)
• Used Shell (cat /root/.nanobot/workspace/skills/gpu/SKILL.md)
• 用户没有说什么，只是等待我继续。让我回顾一下系统提醒 - 我需要继续完成任务并给用户一个完整的总结。
让我做最后的验证，确认一切配置正确，然后给用户一个清晰的总结。
我需要：
1. 验证skill格式是否正确（通过检查nanobot是否能加载）
2. 确保config.json格式正确
3. 提醒用户关于API key的安全问题
4. 给出完整的操作总结
让我先验证skill的格式，可以尝试用nanobot的skill creator的validate功能，或者直接检查YAML frontmatter。
我还应该检查一下bash -l环境下PATH是否包含了我们添加的pathAppend。
• Used Shell (bash -l -c 'which nvcc; w...ch.cuda.is_available())"')
• Used Shell (python -c "import yaml; f...'\\n'.join(frontmatter))")
Failed with exit code: 1
• 用户说继续。让我完成验证并给出最终总结。我需要检查skill的YAML frontmatter格式是否正确。
• Used Shell (python3 -c " with open('/...'\n'.join(frontmatter)) ")
• Used Shell (python -m json.tool /root... echo "config.json valid")
• 用户没有说什么，但我需要继续完成任务。让我做最后的验证和总结。
我需要：
1. 确认skill可以被nanobot识别
2. 测试一下nanobot重启后skill是否生效
3. 给用户一个完整的总结
不过nanobot现在没有在运行。让我检查一下如何启动nanobot。
• Used Shell (nanobot --help 2>&1 | head -30)
• Used Shell (ls -la /root/.nanobot/sessions/)
Failed with exit code: 2
• 用户又发了"继续"，但看起来我的操作已经完成了。让我继续完成最后的验证和总结。
我发现sessions目录不存在 - 实际上我之前看到的是/root/.nanobot/workspace/sessions/。让我再确认一下。
不过更关键的是，我需要给用户一个完整的总结，说明我做了什么，以及如何验证nanobot现在能使用GPU。
让我验证一下skill是否会被nanobot加载，以及如何测试。
• Used Shell (ls -la /root/.nanobot/workspace/sessions/)
• Used Shell (nanobot status 2>&1 || echo "nanobot not running")
• 用户又发了"继续"，看起来可能是想让我继续完成某些事情，或者只是等待我给出最终总结。让我再检查一下是否有遗漏的事项。
让我看看nanobot status的输出 - 它显示了配置是正确的。现在我需要：
1. 确认skill被正确加载 - 可以用nanobot的某个命令检查
2. 给用户完整的总结
让我尝试用nanobot agent直接测试一下，看看skill是否生效。不过这会调用API，可能产生费用。我不应该随意调用。
让我检查一下是否有其他方式来验证skill加载，比如查看nanobot的日志或者直接检查代码中skill的加载逻辑。
或者我可以直接给用户一个完整的总结，告诉他我已经完成了所有配置。
让我再做一件事：检查一下config.json中的API key安全问题，然后给用户总结。
实际上，我发现config.json中有一个OpenAI的apiKey是明文存储的：sk-502cf21c3ff14808b5046b13399a5f6b。这看起来是DeepSeek的key（因为apiBase是https://api.deepseek.com/v1）。我应该
在总结中提醒用户注意这个安全问题。
让我现在给出最终的完整总结。
• Used Shell (grep -c "gpu" /root/.nano...space/skills/gpu/SKILL.md)
• Used Shell (cat /root/.nanobot/config....tool | grep -A8 '"exec"')
• 用户第三次发了"继续"。让我检查一下我是否已经完成了所有必要的工作，然后给用户一个完整的总结。
我已经完成：
1. ✅ 检查GPU可用性 - RTX 4080 SUPER, CUDA 12.8, PyTorch 2.8.0+cu128
2. ✅ 创建gpu skill - /root/.nanobot/workspace/skills/gpu/SKILL.md
3. ✅ 更新config.json - pathAppend和allowedEnvKeys
4. ✅ 更新USER.md - 添加GPU环境信息
让我确认一下nanobot现在是否能识别这个skill。我可以尝试直接读取skill，或者检查nanobot的启动逻辑。
不过实际上，我已经完成了所有必要的配置。让我给用户一个清晰的总结。
但用户连续发了三次"继续"，可能是在等我说话？让我确认一下是否有遗漏。
让我做最后一个验证：检查nanobot的skill加载机制，看看workspace/skills是否被扫描。
• Used Shell (grep -r "skills" /root/.l...er\|workspace" | head -10)
• Used Shell (grep -r "workspace/skills...include="*.py" | head -10)
• 看起来用户一直在等待我完成。让我做最后的确认和总结。代码显示workspace/skills确实会被扫描，而且优先于内置skills。所以我们的配置是正确的。
让我给用户一个完整的总结。
• Used Shell (cat /root/.nanobot/workspace/skills/gpu/SKILL.md)
• Used Shell (python3 -c " import json ...2, ensure_ascii=False)) ")
• 用户又发了"继续"。让我再想想是否还有什么遗漏的。
实际上，我觉得用户可能是在催促我快点给出总结。或者他觉得我还需要做什么额外的验证。
让我做最后一次测试：模拟nanobot的exec工具环境，运行一个真正的PyTorch GPU测试脚本，确认整个链路是通的。然后给出最终的完整总结。
让我写一个测试脚本并通过bash -l -c运行它。
• Used Shell (cat > /root/.nanobot/work...ot/workspace/test_gpu.py")
• 用户又发了"继续"，这已经是第四次了。可能用户希望我做更多的事情，或者只是测试我是否会重复执行。
让我回顾一下用户的原始需求：
1. 检查GPU是否可用 ✅
2. 教会nanobot使用GPU ✅
3. 告诉用户如何做的 ✅
我觉得用户可能是在等待一个最终的、完整的总结报告。让我给出这个总结，然后说明如果需要进一步的测试或调整，可以告诉我。
但我需要注意，config.json中有一个明文API key。我在总结中应该提醒用户。
另外，用户发了好几次"继续"，也许他期望我主动说"已完成"。让我给出最终总结。
• 所有配置已完成，GPU环境验证通过。下面是完整总结：
─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
✅ 完成的事项
1. GPU 环境确认
项目 状态
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
GPU NVIDIA GeForce RTX 4080 SUPER
显存 32 GB
CUDA 12.8
PyTorch 2.8.0+cu128 ✅ torch.cuda.is_available() == True
测试 在 GPU 上成功运行矩阵运算
2. 创建的 Skill：gpu
路径：/root/.nanobot/workspace/skills/gpu/SKILL.md
这个 skill 教会了 nanobot：
• 当前环境有一块 RTX 4080 SUPER 和 CUDA 12.8
• nanobot 自身运行在 uv 隔离的 Python 3.13 环境中，没有 PyTorch
• 执行 GPU 任务时必须用 /root/miniconda3/bin/python（conda base 环境，Python 3.12.3）
• nvidia-smi 等 CUDA 工具已通过 pathAppend 加入 exec 的 PATH
3. 修改的配置：config.json
"exec": {
"pathAppend": "/usr/local/cuda/bin:/root/miniconda3/bin",
"allowedEnvKeys": [
"CUDA_VISIBLE_DEVICES", "CUDA_HOME", "LD_LIBRARY_PATH",
"CONDA_PREFIX", "CONDA_DEFAULT_ENV", "CONDA_SHLVL", "PATH"
]
}
• pathAppend 让 nanobot 的 exec 命令能找到 nvcc、conda python 等工具
• allowedEnvKeys 让 GPU/CUDA 相关的环境变量能透传给子进程
4. 修改的上下文：USER.md
在 Work Context 中添加了 GPU 环境备注，帮助 nanobot 在对话中记住这个环境。
─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
⚠️ 安全提醒
你的 config.json 中第 241 行有一个 明文 API Key：
"apiKey": "sk-502cf21c3ff14808b5046b13399a5f6b"
建议设置合适的文件权限：
chmod 600 /root/.nanobot/config.json
─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
🧪 验证方式
你可以直接问 nanobot（比如通过 nanobot agent 或你配置的渠道）：
▌ "用 PyTorch 在 GPU 上生成一个随机张量并打印设备信息"
它应该会自动调用 gpu skill，并使用 /root/miniconda3/bin/python 来执行代码。
如果你还需要进一步调整（比如增加更多 CUDA 环境变量、安装其他 GPU 库、或者创建更具体的深度学习 skill），告诉我。
── input ──────────────────────7.4 处理结果截图
八、验证 NanoBot 是否成功使用 GPU
现在来测试一下 NanoBot 是否真的学会使用 GPU 了。
8.1 启动 NanoBot
bash
nanobot agent8.2 输入测试指令
用 PyTorch 在 GPU 上生成一个随机张量并打印设备信息8.3 查看运行结果
NanoBot 成功输出了 GPU 相关信息：
运行结果：
项目 值
──────────────────────────────────────
PyTorch 2.8.0+cu128
CUDA 12.8
GPU NVIDIA GeForce RTX 4080 SUPER
设备数 1
随机张量（3×4）已成功创建在 cuda:0 上，shape 为 torch.Size([3, 4])，dtype 为 float32。GPU 工作正常。🎉 完美！NanoBot 已经成功学会使用 GPU 了！
九、核心原理总结
为什么 Kimi Code "教" NanoBot 使用 GPU 这个思路能跑通？核心在于 NanoBot 的 Skill 机制：
| 组件 | 作用 |
|---|---|
| Skill | NanoBot 的能力扩展单元，通过 Markdown 文件描述特定领域的知识和操作规范 |
| config.json | NanoBot 的全局配置，控制工具行为（如 exec 的 PATH 和环境变量透传） |
| USER.md | NanoBot 的持久化上下文，帮助它在对话中记住环境信息 |
Kimi Code 做的本质上是三件事：
- 创建 GPU Skill → 让 NanoBot "知道" 环境中有 GPU 以及具体规格
- 配置 exec 工具 → 让 NanoBot 执行命令时能访问到 conda 环境的 Python 和 CUDA 工具
- 更新上下文 → 让 NanoBot 在后续对话中持续记住这个 GPU 环境
十、结语
通过这篇教程，我们完成了：
- ✅ 在 AutoDL 上安装 Kimi Code
- ✅ 安装并初始化 NanoBot
- ✅ 配置 DeepSeek API
- ✅ 让 Kimi Code 自动教会 NanoBot 使用 GPU
- ✅ 成功验证 GPU 调用
这套组合的威力在于：你只需要告诉 Kimi Code 你的需求，它就能自动在服务器上完成所有配置和优化工作。对于需要频繁调整环境、跑深度学习实验的开发者来说，这大大节省了时间。
如果你也想尝试这个玩法，建议从 AutoDL 的 PyTorch 镜像开始，按照本教程一步步操作即可。遇到问题欢迎在评论区交流！