连这篇分享也是 ai 写的，我一个字没改

写在前面

今天晚上，我花了大约 3 个小时，从零开始，用 AI Coding 的方式撸了一个极简版的 OpenClaw —— 一个跑在 Telegram 上的 AI Agent Bot。它能理解自然语言、自主执行 Linux 命令、还能管理自己的长期和短期记忆。

全程没有人工写一行代码。

对，你没看错。从第一行 import 到最后一行 main()，全部是 AI 生成的。我做的事情只有三件：描述需求、验证结果、推进迭代。

最终的成品 langgraph_native_tg_bot.py，总共 324 行代码。但更有意思的是这个过程本身 —— 它让我深刻体会到了一种全新的编程节奏。

整体思路：小步迭代，像打游戏一样停不下来

先说最重要的一个体会：千万别一上来就想搞个大的。

我没有一开始就说”帮我写一个能执行 bash 命令、有长期记忆的 AI Agent”。这样给 AI，它大概率会给你一坨看起来完整但跑不起来的代码。

我的做法是把整个目标拆成了一个个小关卡，每个关卡只做一件事，做完立刻验证，验证通过就进入下一关。每通过一关都会有一个小小的成就感，这种正反馈会驱动你继续往下推——就像打游戏一样，真的停不下来。

下面就是我的通关路线。

第 1 关：先让 API 通了再说

一切的起点是一个 curl 命令。我手上有 Kimi 的 API，先不管什么 Bot 不 Bot 的，第一步就是确保能在 Python 里成功调用这个 API。

我让 AI 帮我把 curl 翻译成 Python 脚本，写出了 llm_api.py：

import requests
import time
import json
import sys

def make_stream_request():
    url = "https://api.kimi.com/coding/v1/messages"
    
    headers = {
        "x-api-key": "sk-kimi-xxxx",
        "anthropic-version": "2023-06-01",
        "content-type": "application/json"
    }
    
    payload = {
        "model": "kimi-k2.5",
        "max_tokens": 1024,
        "messages": [
            {"role": "user", "content": "你好，请简单介绍一下你自己。"}
        ],
        "stream": True
    }

    print("--- 正在流式生成 ---")
    
    response = requests.post(url, headers=headers, json=payload, stream=True, timeout=60)
    
    full_content = ""
    for line in response.iter_lines():
        if line:
            decoded_line = line.decode('utf-8')
            if decoded_line.startswith("data:"):
                data_str = decoded_line[5:].strip()
                try:
                    data = json.loads(data_str)
                    if data.get("type") == "content_block_delta":
                        chunk = data.get("delta", {}).get("text", "")
                        full_content += chunk
                        print(chunk, end="", flush=True)
                except json.JSONDecodeError:
                    continue
    
    print(f"\n\n--- 生成结束 ---")

if __name__ == "__main__":
    make_stream_request()

跑一下，终端里哗哗地打出来了 LLM 的回复。第 1 关，通过。 ✅

这一步虽然简单，但非常关键。它帮我验证了两件事：API Key 能用、SSE 流式解析的数据格式我搞清楚了。后面所有的迭代都建立在这个确定性之上。

第 2 关：让 Bot 在 Telegram 上活起来

API 通了，下一步是让它跟 Telegram 对接。

但我同样没有急着把 LLM 接进去。我先写了一个纯通信的 Bot —— 只负责收发消息，不调用任何 AI。

这里有个小巧思：我设计了一个配对机制。Bot 首次运行时会生成一个随机验证码，你在 Telegram 里发 /start 验证码 完成配对，之后它只认你一个人。chat_id 会持久化到 bot_config.json 里。

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    config = load_config()
    chat_id = update.effective_chat.id
    
    if "authorized_chat_id" in config:
        if chat_id == config["authorized_chat_id"]:
            await update.message.reply_text("已完成配对，欢迎回来！")
        else:
            await update.message.reply_text("此 Bot 已被他人配对，请联系管理员。")
        return

    args = context.args
    if not args or args[0] != config.get("verification_code"):
        await update.message.reply_text("请输入正确的验证码进行配对，例如：/start [验证码]")
        return

    config["authorized_chat_id"] = chat_id
    save_config(config)
    await update.message.reply_text("配对成功！现在你发的消息我都能在 Ubuntu 上看到了。")

在手机上发了条消息，Ubuntu 终端上立刻打印出来了。第 2 关，通过。 ✅

紧接着我又迭代了一版 tg_bot2.py，实现了双向通信——在 Ubuntu 终端里打字，手机 Telegram 上实时收到。这给了我很大的信心：通信链路是通的，稳定的。

第 3 关：接入 LLM，让 Bot 能思考

通信搞定了，现在把第 1 关的 LLM 能力和第 2 关的 Bot 框架合在一起。

这就是 tg_bot_with_llm.py —— 一个能对话的 AI Bot。发消息给它，它会调用 Kimi API 然后把回复发回来。

这一关的重点是流式输出。如果你等 LLM 生成完再一次性发，用户要等好几秒才能看到回复，体验很差。所以我让 AI 实现了”打字机效果”——LLM 一边生成，Telegram 消息一边更新，还带一个闪烁的光标 ▌。

async for chunk in stream_kimi_response(history):
    full_response += chunk
    
    current_time = time.time()
    if full_response.strip() and (current_time - last_update_time >= update_interval):
        try:
            await placeholder_msg.edit_text(full_response + " ▌")
            last_update_time = current_time
        except BadRequest as e:
            if "Message is not modified" not in str(e):
                logger.warning(f"Telegram 消息更新失败: {e}")

这里有个细节：Telegram 有消息频率限制（Rate Limit），不能每收到一个 chunk 就调一次 edit_text，否则会被限流。所以加了一个 1 秒的更新间隔。

另外这一关我还加上了多轮对话——维护一个 CONVERSATION_HISTORY 字典，每次把完整的对话历史传给 API，实现了上下文记忆。还做了滑动窗口，只保留最近 10 轮，避免 token 爆掉。

在手机上跟它聊了几轮，它能记住之前说过什么。第 3 关，通过。 ✅

第 4 关：迁移到 LangGraph 框架

到这里，一个能用的 AI Telegram Bot 已经成型了。但如果我想让它不只是聊天，还能”做事”（比如执行命令、调用工具），手写的代码结构就不够用了。

所以我决定迁移到 LangGraph。LangGraph 的核心概念是状态图（StateGraph）——你定义节点（Node）、边（Edge），数据在图中流转。这为后面加工具调用打下了基础。

class State(TypedDict):
    messages: Annotated[list, add_messages]

workflow = StateGraph(State)
workflow.add_node("agent", call_model)
workflow.add_edge(START, "agent")
workflow.add_edge("agent", END)
graph = workflow.compile()

这一步的策略是平迁：先不加新功能，只是把原来的代码逻辑套进 LangGraph 的壳子里，确保功能完全一致。平迁成功之后，再在新框架上加新能力。

跑起来，体验和之前一模一样。第 4 关，通过。 ✅

第 5 关：用 LangChain 原生组件替换手写解析

平迁完成后，我又做了一次重要的重构：引入 langchain-anthropic SDK，替换掉之前手写的 httpx SSE 解析逻辑。

因为 Kimi 兼容 Anthropic 协议，所以可以直接用 ChatAnthropic，只需要把 anthropic_api_url 指向 Kimi 的地址：

llm = ChatAnthropic(
    model="kimi-k2.5",
    anthropic_api_key=KIMI_API_KEY,
    anthropic_api_url=KIMI_URL,
    max_tokens=2048,
    streaming=True
)

流式输出也从手动解析 SSE 包变成了一行：

async for mode, data in graph.astream(
    {"messages": history}, 
    stream_mode=["messages", "updates", "values"]
)

代码量直接砍掉一大块，而且消息对象变成了标准的 HumanMessage / AIMessage，后面接工具链就是水到渠成的事。

第 5 关，通过。 ✅

第 6 关：赋予 Agent 执行命令的能力

这是最激动人心的一关。

我让 AI 帮我加了一个 execute_bash 工具，然后用 LangGraph 的 ToolNode + tools_condition 构建了一个 ReAct 循环：Agent 思考 → 决定是否需要执行命令 → 执行 → 观察结果 → 继续思考或回复。

@tool
def execute_bash(command: str) -> str:
    """在 Ubuntu bash 中执行命令并返回输出。"""
    process = subprocess.Popen(
        command, shell=True,
        stdout=subprocess.PIPE, stderr=subprocess.PIPE,
        text=True, executable='/bin/bash'
    )
    stdout, stderr = process.communicate(timeout=60)
    output = stdout.strip()
    if stderr.strip():
        output += f"\nStderr:\n{stderr.strip()}"
    return output if output else "命令执行成功，无输出。"

tools = [execute_bash]
llm_with_tools = llm.bind_tools(tools)

workflow = StateGraph(State)
workflow.add_node("agent", call_model)
workflow.add_node("tools", ToolNode(tools))
workflow.add_edge(START, "agent")
workflow.add_conditional_edges("agent", tools_condition)
workflow.add_edge("tools", "agent")
graph = workflow.compile()

在 Telegram 里跟它说”帮我看看服务器磁盘用了多少”，它自己组装了 df -h 命令，执行完把结果总结给我。

这一关踩了不少坑：

• • Telegram 的 MarkdownV2 解析器在流式场景下各种报错（比如 Docker 镜像名里的下划线），最后全面切到 HTML 模式 才搞定
• • 工具调用链条中的 tool_call_id 必须匹配，否则 LangGraph 会报错，最后用 stream_mode=["messages", "updates", "values"] 混合流模式解决
• • 把”思考过程”、”准备执行命令”、”执行结果”、”最终回复”拆成了独立消息，交互透明度拉满

第 6 关，通过。 ✅

第 7 关：赋予 Agent 记忆

最后一关：让 Agent 拥有长期记忆和短期记忆。

设计很朴素——用文件系统：

• • long_term_memory/long_term_memory.md：存放长期信息（比如用户偏好）
• • short_term_memory/20260305.md：按日期存放的短期操作日志

关键的实现是动态上下文注入。每次 Agent 决策前，系统会实时读取长期记忆文件的内容，注入到 System Prompt 中：

async def call_model(state: State):
    system_prompt_template = (
        "你是一个聪明且有用的 ai 助手...\n"
        "以下是来自 long_term_memory.md 的内容：\n"
        "{{{long_term_memory.md}}}"
    )
    
    ltm_path = "long_term_memory/long_term_memory.md"
    if os.path.exists(ltm_path):
        with open(ltm_path, "r", encoding="utf-8") as f:
            ltm_content = f.read()
    
    system_prompt = system_prompt_template.replace(
        "{{{long_term_memory.md}}}", 
        ltm_content if ltm_content.strip() else "(长期记忆目前为空)"
    )
    
    messages = [SystemMessage(content=system_prompt)] + state["messages"]
    response = await llm_with_tools.ainvoke(messages)
    return {"messages": [response]}

妙的地方在于：Agent 可以通过 execute_bash 工具主动读写这些记忆文件。它自己决定什么信息值得长期记住、什么只是短期流水。而且因为每次决策前都会重新读取文件，所以如果它上一步刚更新了记忆，下一步立刻就能”想起来”。

Bot 重启后，聊天历史虽然没了，但长期记忆还在磁盘上。跟它说”你还记得我是谁吗”，它读了一下 long_term_memory.md，回答：”你是 aden。”

第 7 关，通过。 ✅ 🎉

最终成品：324 行的极简 Agent

最终的 langgraph_native_tg_bot.py，324 行代码，包含了：

• • ✅ Telegram Bot 通信
• • ✅ LLM 对话（流式输出 + 打字机效果）
• • ✅ 多轮对话上下文管理
• • ✅ ReAct Agent（思考-行动-观察循环）
• • ✅ Bash 命令执行能力
• • ✅ 长期/短期记忆管理
• • ✅ Token 用量统计
• • ✅ 完善的日志和异常处理

你可以在 Telegram 上跟它说”帮我看看 Docker 里跑了什么”，它会自己执行 docker ps，然后给你一份整理好的报告。你也可以说”记住我喜欢简洁的回复风格”，它会主动写入长期记忆。

几点感悟

1. AI Coding 的正确姿势：小步迭代

回头看整个过程，7 个阶段，每个阶段都是一个独立的、可验证的小目标。这不是什么方法论，这是实操下来最自然的节奏。

你不需要一次性描述清楚所有需求。你只需要知道下一步要做什么，告诉 AI，验证结果，然后继续。每一步的成功都会给你信心和动力推进下一步——这种感觉真的就像打游戏通关一样，停不下来。

2. AI 擅长从零写，不擅长改

这是我在过程中一个很强烈的体会。

当我需要做架构升级（比如从手写 API 调用迁移到 LangGraph），我不会说”帮我改一下现有代码”。我会把现有代码给 AI 看，然后说”基于这个，帮我写一个新的文件“。

AI 从零写一个完整文件的质量，远高于它在一个已有文件上改来改去。所以你会看到我的项目里有好几个文件：tg_bot.py → tg_bot2.py → tg_bot_with_llm.py → langgraph_tg_bot_with_llm.py → langgraph_native_tg_bot.py。每一个都是基于上一个的完整重写，而不是在同一个文件上打补丁。

3. 没有写一行代码，但你得懂代码

虽然全程是 AI 写的代码，但这并不意味着你可以完全不懂技术。你需要能看懂 AI 给你的代码、能判断它的方案是否合理、能在它犯错时指出问题所在。

AI Coding 不是”不写代码”，而是”用更高效的方式写代码”。你的角色从”打字员”变成了”架构师 + 审核者”。

4. 对了，这篇文章本身也是 AI 写的

最后说一个有趣的事：你正在读的这篇分享文章，也是 AI 写的。

我把 work_note（开发日志）和全部源码丢给 AI，告诉它用第一人称写一篇分享文章，它就生成了你看到的这些内容。

所以这个项目从第一行代码到最后一个字的分享，形成了一个完整的闭环：全部由 AI 完成，人类只负责驱动和决策。

写在最后

3 个小时，324 行代码，从一个 curl 命令到一个能执行系统命令、拥有记忆能力的 AI Agent。

这不是什么炫技，而是想说明一件事：在 AI Coding 时代，瓶颈不再是”能不能写出来”，而是”知不知道该写什么”。 想清楚目标、拆解好步骤、保持小步迭代的节奏，AI 会帮你把剩下的事情搞定。

如果你也想试试，不妨从一个 curl 命令开始。