我用了 5 分钟，把蓝耘 MaaS 接进 Python，写了个命令行 AI 编程助手

每日一句

前半生择其所爱，
余下的岁月爱其所择。

---

一、困境：当编程遇到“卡壳”

写代码的时候，最怕什么？

不是复杂的业务逻辑，不是难懂的框架文档，而是那种明明很简单、却偏偏想不起来的“语法盲区”。比如正则表达式里那个非捕获分组的写法，比如 Python 装饰器带参数时的三层嵌套结构，比如 Linux 下 find 命令按文件大小筛选的参数顺序。

一旦卡在这种地方，手就会习惯性地离开键盘，切到浏览器，打开搜索引擎，输入关键词，然后——

点开第一个结果：广告。

点开第二个结果：答案是三年前的，Python 版本还对不上。

点开第三个结果：洋洋洒洒几千字，划到底部发现“关注公众号查看完整内容”。

关掉页面，再搜一次。如此反复几次，原本写代码的节奏感彻底断了，再坐回编辑器前，重新进入状态又得好几分钟。

这种“打断—恢复—再打断”的循环，消耗的不仅是时间，更是注意力和心流。

二、需求：一个不离开终端的 AI 助手

其实很早之前就想搞一个命令行 AI 助手了。

需求很简单：在终端里直接问问题，不切换窗口，不打开浏览器，AI 直接在命令行里给出答案。

但之前的思路一直绕不开那个老套路——

买一台服务器 → 装 Docker → 拉镜像 → 部署开源模型 → 配置 GPU 驱动 → 调参优化。

这一套组合拳打下来，先不说钱，光是环境就能折腾一整天。

也想过用 C++ 来调大模型的 API。毕竟 C++ 性能好、底子硬，感觉更“专业”。但真动手之后才发现——光一个 cpp-httplib 的编译就搞了半天，SSL 库版本不匹配、mutex 头文件报错、最后连 g++ 的 -lws2_32 参数都跟我过不去。写了一堆代码，结果全在跟编译器搏斗。

于是换了个思路：选最轻量的方式，先跑起来再说。

三、解决方案：蓝耘 MaaS + Python，五分钟搞定

3.1 什么是蓝耘 MaaS？

蓝耘 MaaS（Model as a Service）是一个大模型服务平台，说白了就是把 DeepSeek、GLM、Qwen、Kimi 这些热门模型打包成标准的 API 服务。不用自己部署模型，不用管 GPU，注册之后拿到一个 API Key 就能直接调用。

更重要的是，蓝耘 MaaS 的接口完全兼容 OpenAI 的 API 格式。这意味着所有你用过的 OpenAI SDK 调用代码，把 base_url 改一下就能直接跑，零学习成本。

接口地址是固定的：

https://maas-api.lanyun.net/v1

模型名称长这样（以 DeepSeek-V3.2 为例）：

/maas/deepseek-ai/DeepSeek-V3.2

3.2 准备工作

注册登录蓝耘元生代MaaS官网平台，完成个人实名认证后，即可进入模型广场和应用管理模块。我们需要提前创建应用、开通模型调用权限、生成专属API Key，这个密钥是后续OpenClaw对接蓝耘大模型的唯一凭证，相当于开门钥匙，一定要妥善保存，不要随意泄露给他人，避免被盗用产生额外消耗。蓝耘官网

第一步：搞到 API Key

打开 蓝耘 GPU 智算云平台（https://www.lanyun.net），注册一个账号。进控制台，在左侧菜单找到「API KEY 管理」，点击「创建 API KEY」，系统会生成一串密钥，复制下来保存好。

蓝耘新用户注册会赠送免费试用额度，够测试好几天了

第二步：装一个库

打开终端，一行命令：

pip install openai

就这一行。不需要别的。

3.3 核心代码拆解

完整代码大约 90 行。先看全貌，再逐块拆。

初始化客户端

from openai import OpenAI
API_KEY = "你的蓝耘API_KEY"
BASE_URL = "https://maas-api.lanyun.net/v1"
MODEL = "/maas/deepseek-ai/DeepSeek-V3.2"
client = OpenAI(api_key=API_KEY, base_url=BASE_URL)

除了 BASE_URL 指向蓝耘的 MaaS 接口，其他代码和你调 GPT 一模一样。

设定 AI 的角色

SYSTEM_PROMPT = """你是一个专业的编程助手，精通 Python、C++、Java 等主流语言。
你的任务：
1. 回答编程问题，给出可直接运行的代码
2. 解释复杂的技术概念
3. 生成命令行指令
请用简洁专业的语言回答，代码块用 Markdown 格式标注。"""

System Prompt 是整个助手的“人设”。把它设定成编程专家，并要求用 Markdown 格式输出代码，在终端里看起来清晰明了。

流式调用 API（核心逻辑）

def chat(question):
    messages = [
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": question}
    ]
    response = client.chat.completions.create(
        model=MODEL,
        messages=messages,
        stream=True,          # 流式输出，像打字机一样逐字显示
        temperature=0.3,      # 编程场景，降低随机性
        timeout=30
    )
    print("n🤖 AI 回复：n" + "─" * 50)
    full_reply = ""
    for chunk in response:
        if not chunk.choices:
            continue
        delta = chunk.choices[0].delta
        if delta and delta.content:
            content = delta.content
            print(content, end="", flush=True)
            full_reply += content
    print("n" + "─" * 50 + "n")
    return full_reply

几个关键参数：

• stream=True：让回复像 ChatGPT 一样逐字输出，体验极佳
• temperature=0.3：编程问题要的是准确，不是创意，所以降低随机性
• timeout=30：避免网络波动导致卡死

交互模式

def main():
    parser = argparse.ArgumentParser(
        description="蓝耘 AI 编程助手 - 命令行里的编程百事通"
    )
    parser.add_argument("question", nargs="?", help="你的编程问题")
    parser.add_argument("-i", "--interactive", action="store_true", help="进入交互模式")
    args = parser.parse_args()
    if args.question:
        chat(args.question)
    else:
        print("╔══════════════════════════════════════╗")
        print("║   🚀 蓝耘 AI 编程助手 (交互模式)      ║")
        print("║   输入问题开始，输入 exit 退出        ║")
        print("╚══════════════════════════════════════╝")
        while True:
            user_input = input("n💬 你: ").strip()
            if user_input.lower() == "exit":
                print("👋 再见！")
                break
            if not user_input:
                continue
            chat(user_input)

两种使用方式：

• python main.py "用Python写个快速排序" —— 单次快问快答
• python main.py —— 进入交互循环，连续提问

从打开编辑器到跑通第一个问题，前后不到五分钟。

四、实测效果

4.1 代码生成：快速排序

先来一个经典的——快速排序。

在命令行输入：

用 Python 写一个快速排序

AI 返回的内容分为三个部分：

第一部分：代码实现

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

这是非原地版本，逻辑清晰，适合初学者理解分治思想。代码里还加了详细的注释，每一行在做什么都标得明明白白。

第二部分：原地排序版本（进阶）

AI 没止步于基础实现，紧接着给出了原地排序版本——用指针交换元素，省内存，适合大数据量场景。而且特别标注了 # 如果子数组长度小于阈值，可以考虑改用插入排序，连优化方向都指出来了。

第三部分：测试用例

# 测试
print(quicksort([3, 6, 8, 10, 1, 2, 1]))
# 输出: [1, 1, 2, 3, 6, 8, 10]

不仅有普通用例，还附带了空数组、单元素数组、已排序数组、倒序数组这些边界情况——都是面试里常见的考察点。最后补了一句时间复杂度分析：平均 O(n log n)，最坏 O(n²)。

第四部分：输出答案

def quicksort(arr):
    """
    快速排序主函数
    :param arr: 待排序的列表
    :return: 排序后的列表
    """
    if len(arr) <= 1:
        return arr
    # 选择基准元素（这里选择中间元素）
    pivot = arr[len(arr) // 2]
    # 分区操作
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    # 递归排序并合并结果
    return quicksort(left) + middle + quicksort(right)
def quicksort_inplace(arr, low=0, high=None):
    """
    原地快速排序（节省内存空间）
    :param arr: 待排序的列表
    :param low: 起始索引
    :param high: 结束索引
    """
    if high is None:
        high = len(arr) - 1
    if low < high:
        # 获取分区索引
        pi = partition(arr, low, high)
        # 递归排序左右分区
        quicksort_inplace(arr, low, pi - 1)
        quicksort_inplace(arr, pi + 1, high)
def partition(arr, low, high):
    """
    分区函数（Lomuto分区方案）
    :return: 基准元素的最终位置
    """
    # 选择最右边的元素作为基准
    pivot = arr[high]
    # 较小元素的索引
    i = low - 1
    for j in range(low, high):
        # 如果当前元素小于等于基准
        if arr[j] <= pivot:
            i += 1
            arr[i], arr[j] = arr[j], arr[i]
    # 将基准元素放到正确位置
    arr[i + 1], arr[high] = arr[high], arr[i + 1]
    return i + 1
# 测试代码
if __name__ == "__main__":
    # 测试数据
    test_arr = [64, 34, 25, 12, 22, 11, 90, 88]
    print("原始数组:", test_arr)
    # 方法1：使用非原地版本
    sorted_arr = quicksort(test_arr.copy())
    print("非原地快速排序结果:", sorted_arr)
    # 方法2：使用原地版本
    arr_copy = test_arr.copy()
    quicksort_inplace(arr_copy)
    print("原地快速排序结果:", arr_copy)
    # 测试边缘情况
    print("n边缘情况测试:")
    print("空数组:", quicksort([]))
    print("单元素数组:", quicksort([5]))
    print("已排序数组:", quicksort([1, 2, 3, 4, 5]))
    print("逆序数组:", quicksort([5, 4, 3, 2, 1]))

并且还有：

## 算法说明：
### 1. **基本思想**：
- 选择一个基准元素（pivot）
- 将数组分为两部分：小于基准的元素和大于基准的元素
- 递归地对两部分进行排序
### 2. **两种实现方式**：
- **`quicksort()`**：非原地版本，易于理解但需要额外内存
- **`quicksort_inplace()`**：原地版本，节省内存空间
### 3. **时间复杂度**：
- 平均情况：O(n log n)
- 最坏情况（已排序数组）：O(n²)
- 最佳情况：O(n log n)
### 4. **空间复杂度**：
- 非原地版本：O(n)
- 原地版本：O(log n)（递归栈空间）
### 5. **优化建议**：
1. 随机选择基准元素以避免最坏情况
2. 对小数组使用插入排序（混合排序）
3. 使用三数取中法选择基准
运行上述代码将输出：
原始数组: [64, 34, 25, 12, 22, 11, 90, 88]
非原地快速排序结果: [11, 12, 22, 25, 34, 64, 88, 90]
原地快速排序结果: [11, 12, 22, 25, 34, 64, 88, 90]
边缘情况测试:
空数组: []
单元素数组: [5]
已排序数组: [1, 2, 3, 4, 5]
逆序数组: [1, 2, 3, 4, 5]

4.2 概念解释：Python 装饰器

第二个测试用来检验概念解释能力。输入：

解释 Python 装饰器，给个计时器例子

AI 的回复结构很讲究。先是简洁的概念解释——两句说清楚“装饰器本质上是一个接收函数作为参数、返回新函数的可调用对象”，接着展开三步走：闭包、函数作为一等公民、语法糖。每步一句话，不堆砌术语。

然后直接上答案：

## Python 装饰器
**装饰器（Decorator）** 是 Python 中一种特殊的语法，用于修改或增强函数/类的行为，而无需修改其源代码。它本质上是一个**高阶函数**，接受一个函数作为参数，并返回一个新的函数。
### 核心概念：
1. **函数是一等对象**：可以像变量一样传递、赋值
2. **闭包（Closure）**：内部函数可以访问外部函数的变量
3. **语法糖**：`@decorator` 是 `func = decorator(func)` 的简洁写法
## 计时器装饰器示例
import time
from functools import wraps
def timer(func):
    """装饰器：测量函数执行时间"""
    @wraps(func)  # 保留原函数的元信息（名称、文档等）
    def wrapper(*args, **kwargs):
        start_time = time.perf_counter()  # 高精度计时
        result = func(*args, **kwargs)    # 执行原函数
        end_time = time.perf_counter()
        elapsed = end_time - start_time
        print(f"[{func.__name__}] 执行时间: {elapsed:.6f} 秒")
        return result  # 返回原函数的执行结果
    return wrapper
# 使用装饰器
@timer
def example_function(n):
    """示例函数：计算 0 到 n-1 的平方和"""
    total = 0
    for i in range(n):
        total += i ** 2
    return total
@timer
def slow_function(delay=0.5):
    """模拟耗时操作"""
    time.sleep(delay)
    return "完成"
# 测试
if __name__ == "__main__":
    # 测试计算函数
    result = example_function(10000)
    print(f"计算结果: {result}n")
    # 测试延时函数
    slow_function(0.3)
    # 验证元信息保留
    print(f"n函数名: {example_function.__name__}")
    print(f"文档: {example_function.__doc__}")
### 输出示例：
[example_function] 执行时间: 0.001234 秒
计算结果: 332833500
[slow_function] 执行时间: 0.300456 秒
函数名: example_function
文档: 示例函数：计算 0 到 n-1 的平方和
## 关键点说明：
1. **`@wraps(func)` 的作用**：
   - 保持原函数的 `__name__`、`__doc__` 等属性
   - 不加 `@wraps` 时，被装饰函数会显示为 `wrapper`
2. **`*args, **kwargs`**：
   - 确保装饰器能处理任意参数的函数
   - `args` 接收位置参数
   - `kwargs` 接收关键字参数
3. **装饰器执行顺序**（多个装饰器时）：
```python
@decorator1
@decorator2
def func():
    pass
# 等价于：func = decorator1(decorator2(func))
4. **带参数的装饰器**：
```python
def repeat(n=2):
    """重复执行 n 次的装饰器"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for i in range(n):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator
@repeat(n=3)
@timer
def hello():
    print("Hello!")
装饰器广泛应用于日志记录、性能测试、权限验证、缓存等场景，是 Python 中实现 AOP（面向切面编程）的重要工具。

4.3 命令行生成：Linux 命令

有些时候，卡住不是因为不会写代码，而是记不清 Linux 命令的参数。输入：

python main.py "递归查找当前目录下大于100MB的文件"

返回干净利落：

find . -type f -size +100M

紧接着逐条解释：

• . 表示当前目录
• -type f 只查文件，跳过目录
• -size +100M 大于 100 兆

4.4 C++编程

输入：C++打印Hello World

输出：

#include <iostream>
int main() {
    std::cout << "Hello World" << std::endl;
    return 0;
}

4.5 实测小结

测试项	输入类型	响应质量	耗时
快速排序	算法实现	两种版本 + 边界测试 + 复杂度分析	~2s
装饰器	概念解释	概念 + 代码 + 语法糖说明	~1.8s
Linux 命令	CLI 生成	命令 + 逐参数拆解	~1.2s
Bug 修复	代码纠错	根因分析 + 2 种修复方案	~2.1s

五、为什么选蓝耘 MaaS平台

5.1 OpenAI 兼容，零迁移成本

在 AI 编程助手的方案选型阶段，我评估过几种不同的模型调用方式。最简单粗暴的方式是直接用各大云厂商的 SDK——每家的鉴权方式、请求格式、错误码定义都不一样，换一家就得重写一套，适配成本极高。

蓝耘 MaaS 走的是另一条路：完全兼容 OpenAI 的 API 规范。

这意味着什么？现在市面上所有基于 OpenAI SDK 开发的开源项目、教程代码、工具链，只要把 base_url 和 api_key 换成蓝耘的，就能无缝跑起来。代码不用改，文档不用重读，生态直接复用。

对于开发者来说，这省掉了一个非常现实的成本——学习成本。

5.2 按量计费，对个人开发者友好

个人开发者用大模型 API，最怕两件事：一是付了月费但用得少，亏；二是敞开了用但月底账单吓人。

蓝耘采用的是纯按 Token 计费模式，用多少付多少，没有最低消费，没有月租门槛。以 DeepSeek R1 为例，输入 2 元/百万 token，输出 8 元/百万 token。聊一下午的编程问题，token 消耗可能不到 1 万，折合下来也就几分钱。

做个简单的对比：

方案	月成本	适用场景
买一台云服务器（4C8G）	200-400 元/月	需要长期运行服务
自己部署开源模型（GPU）	1000+ 元/月	企业级生产环境
蓝耘 MaaS 按量计费	几元至几十元/月（按实际用量）	个人开发、学习、测试

作为一个命令行工具，我不想为“偶尔问几个问题”支付固定成本。蓝耘这种用一次付一次的方式，正好匹配这个需求。

5.3 性能满足日常使用

根据 AI Ping 的公开数据，蓝耘平台上的 DeepSeek-V3.2 实现了 217.48 tokens/s 的吞吐成绩，支持 128K 超长上下文。实测下来，命令行助手的响应速度完全没有感知延迟，流式输出也足够丝滑。

对于命令行工具来说，性能要求其实很简单：别让我等。每次输入问题后 1-2 秒内开始输出，流式逐字显示过程中没有卡顿断流，这就够了。蓝耘做到了。

5.4 新用户免费额度

注册就送每个文本模型 100 万 Token 的免费试用额度，可以先用完再决定要不要继续。对初次尝试的开发者来说，这个门槛基本为零。

5.5 选型对比

对比维度	自己部署开源模型	某云厂商 API	蓝耘 MaaS
需要 GPU 服务器	✅ 必须	❌ 不需要	❌ 不需要
初始化配置耗时	数天	数小时（学习 SDK）	5 分钟
计费方式	月租固定	按量 / 包月	按 Token，无月费
OpenAI 兼容	❌ 不兼容	❌ 通常不兼容	✅ 完全兼容
学习成本	高	中	零（复用 OpenAI 生态）

六、扩展方向

这个命令行 AI 编程助手只是基础版本，后续还可以加入很多能力：

• 支持读取本地代码文件：把当前正在写的代码作为上下文传给蓝耘 MaaS，让 AI 基于已有代码做分析、补全、重构
• 用 colorama 给输出加颜色高亮：让终端里的代码块看起来更舒服
• 保存对话历史到本地文件：下次启动时自动加载，实现跨会话记忆
• 接入蓝耘的智能路由功能：根据问题类型（代码生成 vs 概念解释 vs 命令生成）自动选择最优模型

感兴趣的可以去 蓝耘官网（https://www.lanyun.net）注册试试，注册送试用额度，够玩好几天了。