豆包 1.5 Pro 接入 飞书 完整指南：方舟接入点 + 加签机器人与自建应用双路径实测

1每日 tokens：120 × 3 × (400 + 500) = 324,000 tokens
2走 doubao-1.5-pro-32k：0.096 + 0.30 = 约 ¥0.40/天，约 ¥12/月
3走 doubao-1.5-lite-32k：约 ¥0.16/天，约 ¥4.8/月
4混合（70% lite + 30% pro）：约 ¥0.23/天，约 ¥7/月

1❌ 重度代码生成与复杂重构（豆包能写代码，但不如专攻代码的模型稳）
2❌ 需要严格 JSON Schema 给下游消费（建议加后处理校验 + 失败重试）
3❌ 超大长文一次性吞进（32K 版本不够，要么用 256k 版本要么自己做切片）
4❌ 强实时信息问答（模型知识有截止，需要自己接检索或插件）

1Webhook 地址：
2https://open.feishu.cn/open-apis/bot/v2/hook/1a2b3c4d-5e6f-4708-9182-a3b4c5d6e7f8
3
4密钥（secret）：
5Bv4Nq7Rt2Wz9Yc3

1import hmac, hashlib, time
2
3def gen_sign(secret: str) -> tuple[str, str]:
4    """飞书自定义机器人加签。三个易错点：
5    1) timestamp 用秒，不要 int(time.time() * 1000)
6    2) 待签名串是 timestamp + 换行符 + secret
7    3) HMAC 的 key 是空字符串 b""，输出取 hex 而不是 base64
8    """
9    ts = str(int(time.time()))
10    sign = hmac.new(b"", f"{ts}\n{secret}".encode("utf-8"), hashlib.sha256).hexdigest()
11    return ts, sign

1import httpx
2
3WEBHOOK = "https://open.feishu.cn/open-apis/bot/v2/hook/1a2b3c4d-5e6f-4708-9182-a3b4c5d6e7f8"
4SECRET = "Bv4Nq7Rt2Wz9Yc3"
5
6def push(msg_type: str, content: dict) -> dict:
7    ts, sign = gen_sign(SECRET)
8    body = {"timestamp": ts, "sign": sign, "msg_type": msg_type, "content": content}
9    return httpx.post(WEBHOOK, json=body, timeout=10).json()
10    # 成功 {"code":0,"msg":"success"}；失败 {"code":19021,"msg":"sign match fail..."}
11
12print(push("text", {"text": "豆包 1.5 Pro 接入测试"}))

1import crypto from 'node:crypto';
2
3const WEBHOOK = 'https://open.feishu.cn/open-apis/bot/v2/hook/1a2b3c4d-5e6f-4708-9182-a3b4c5d6e7f8';
4const SECRET = 'Bv4Nq7Rt2Wz9Yc3';
5
6function genSign(secret) {
7  const ts = String(Math.floor(Date.now() / 1000));   // 秒级！不要 Date.now()
8  const sign = crypto
9    .createHmac('sha256', Buffer.alloc(0))             // 空 Buffer 作密钥
10    .update(`${ts}\n${secret}`)
11    .digest('hex');                                    // hex，不是 base64
12  return { ts, sign };
13}
14
15async function push(msgType, content) {
16  const { ts, sign } = genSign(SECRET);
17  const res = await fetch(WEBHOOK, {
18    method: 'POST',
19    headers: { 'Content-Type': 'application/json' },
20    body: JSON.stringify({ timestamp: ts, sign, msg_type: msgType, content }),
21  });
22  return res.json();
23}

1echo 'export ARK_API_KEY="8f7e6d5c-4b3a-2918-1706-f5e4d3c2b1a0"' >> ~/.bashrc
2echo 'export ARK_EP_PRO="ep-20260723143022-x8k2m"' >> ~/.bashrc
3echo 'export ARK_EP_LITE="ep-20260723143105-p4n7q"' >> ~/.bashrc
4source ~/.bashrc

1feishu-doubao-bot/
2├── .env          # 密钥与接入点 ID，务必加进 .gitignore
3├── .gitignore    # 至少一行：.env
4├── bot.py
5└── card.py

1import os, json, time, hmac, hashlib, httpx
2
3WEBHOOK = os.environ["FEISHU_WEBHOOK"]
4SECRET  = os.environ["FEISHU_SECRET"]
5ARK_KEY = os.environ["ARK_API_KEY"]
6ARK_URL = "https://ark.cn-beijing.volces.com/api/v3/chat/completions"
7
8EP_PRO  = os.environ["ARK_EP_PRO"]    # ep-20260723143022-x8k2m
9EP_LITE = os.environ["ARK_EP_LITE"]   # ep-20260723143105-p4n7q
10
11SYSTEM_PROMPT = """你是飞书群里的 AI 助手，底层模型是豆包 1.5 Pro。
12回答要求：
131. 中文，简洁，控制在 300 字以内，能用列表就用列表
142. 涉及营销文案时给出 2-3 个版本，标注各自风格
153. 不确定就明确说不确定，不要编造数据、价格、日期
164. 用户要求改写时只输出改写结果，不要解释改了什么
17"""
18
19def ask_doubao(question: str, ep: str | None = None, timeout: int = 30) -> tuple[str, int]:
20    """返回 (回答, 总 token 消耗)。ep 为接入点 ID，不传则自动路由。"""
21    ep = ep or route_endpoint(question)
22    r = httpx.post(
23        ARK_URL,
24        headers={"Authorization": f"Bearer {ARK_KEY}"},
25        json={
26            "model": ep,          # 注意：这里是接入点 ID，不是模型名
27            "messages": [
28                {"role": "system", "content": SYSTEM_PROMPT},
29                {"role": "user", "content": question},
30            ],
31            "temperature": 0.3,
32            "max_tokens": 1024,
33        },
34        timeout=timeout,
35    )
36    data = r.json()
37    if "choices" not in data:
38        raise RuntimeError(f"豆包调用失败：{data}")
39    return data["choices"][0]["message"]["content"], data["usage"]["total_tokens"]
40
41def route_endpoint(question: str) -> str:
42    """简单的成本路由：格式类任务走 lite，其余走 pro"""
43    cheap = any(k in question for k in ["转换", "分类", "摘要", "提取", "提取出", "格式"])
44    return EP_LITE if (cheap and len(question) < 200) else EP_PRO
45
46def gen_sign(secret: str) -> tuple[str, str]:
47    ts = str(int(time.time()))
48    return ts, hmac.new(b"", f"{ts}\n{secret}".encode(), hashlib.sha256).hexdigest()
49
50def push(msg_type: str, content: dict) -> dict:
51    ts, sign = gen_sign(SECRET)
52    return httpx.post(WEBHOOK, json={
53        "timestamp": ts, "sign": sign, "msg_type": msg_type, "content": content
54    }, timeout=10).json()
55
56if __name__ == "__main__":
57    q = "帮我给这场直播写 3 条标题，要有网感"
58    answer, tokens = ask_doubao(q)
59    print(push("text", {"text": f"{answer}\n\n（豆包 1.5 Pro · {tokens} tokens）"}))

1pip install httpx python-dotenv
2python bot.py
3# 控制台打印 {'code': 0, 'msg': 'success', 'data': {}} 即链路打通

1{
2  "msg_type": "interactive",
3  "card": {
4    "config": { "wide_screen_mode": true, "enable_forward": true },
5    "header": {
6      "template": "orange",
7      "title": { "tag": "plain_text", "content": "豆包 1.5 Pro · 文案助手" },
8      "subtitle": { "tag": "plain_text", "content": "接入点 ep-...-x8k2m · 1.2s · 858 tokens" }
9    },
10    "elements": [
11      { "tag": "div", "text": { "tag": "lark_md", "content": "**你的需求**\n给这场直播写 3 条标题，要有网感" } },
12      { "tag": "hr" },
13      { "tag": "div", "text": { "tag": "lark_md", "content": "**版本一（悬念型）**\n..." } },
14      { "tag": "div", "text": { "tag": "lark_md", "content": "**版本二（直给型）**\n..." } },
15      { "tag": "note", "elements": [
16        { "tag": "plain_text", "content": "AI 生成内容，发布前请人工核对" }
17      ]}
18    ],
19    "actions": [
20      { "tag": "action", "actions": [
21        { "tag": "button", "text": { "tag": "plain_text", "content": "再来 3 条" },
22          "type": "primary", "value": { "action": "more", "qid": "8823" } },
23        { "tag": "button", "text": { "tag": "plain_text", "content": "换个风格" },
24          "type": "default", "value": { "action": "restyle", "qid": "8823" } },
25        {
26          "tag": "select_static",
27          "placeholder": { "tag": "plain_text", "content": "定稿发给谁？" },
28          "value": { "action": "assign" },
29          "options": [
30            { "text": { "tag": "plain_text", "content": "发给内容组" }, "value": "content" },
31            { "text": { "tag": "plain_text", "content": "发给设计组配图" }, "value": "design" }
32          ]
33        }
34      ]}
35    ]
36  }
37}

1def build_copy_card(question: str, answer: str, elapsed: float, tokens: int,
2                    ep: str, qid: str = "") -> dict:
3    return {
4        "config": {"wide_screen_mode": True, "enable_forward": True},
5        "header": {
6            "template": "orange",
7            "title": {"tag": "plain_text", "content": "豆包 1.5 Pro · 回答"},
8            "subtitle": {"tag": "plain_text",
9                         "content": f"接入点 {ep} · {elapsed:.1f}s · {tokens} tokens"},
10        },
11        "elements": [
12            {"tag": "div", "text": {"tag": "lark_md", "content": f"**你的问题**\n{question}"}},
13            {"tag": "hr"},
14            {"tag": "div", "text": {"tag": "lark_md", "content": answer}},
15            {"tag": "note", "elements": [
16                {"tag": "plain_text", "content": "AI 生成内容，发布前请人工核对"}
17            ]},
18        ],
19        "actions": [{
20            "tag": "action",
21            "actions": [
22                {"tag": "button", "text": {"tag": "plain_text", "content": "再来 3 条"},
23                 "type": "primary", "value": {"action": "more", "qid": qid}},
24                {"tag": "button", "text": {"tag": "plain_text", "content": "换个风格"},
25                 "type": "default", "value": {"action": "restyle", "qid": qid}},
26            ],
27        }],
28    }
29
30push("interactive", build_copy_card(q, answer, 1.2, 858, EP_PRO, "8823"))

1App ID：     cli_e5f6g7h8i9j0k1l2
2App Secret： Bv4Nq7Rt2Wz9Yc3A4b5C6d7E8f9G0h1

1import os, time, threading, httpx
2
3APP_ID = os.environ["FEISHU_APP_ID"]
4APP_SECRET = os.environ["FEISHU_APP_SECRET"]
5FS_TOKEN_URL = "https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal"
6
7_fs = {"token": None, "expire_at": 0}
8_fs_lock = threading.Lock()
9
10def get_tenant_access_token() -> str:
11    """有效期 2 小时，过期前 5 分钟刷新。
12    为什么必须缓存：飞书对鉴权接口有独立限流，高频换取会被拒绝，
13    进而导致所有发消息请求失败。
14    """
15    now = time.time()
16    if _fs["token"] and _fs["expire_at"] - now > 300:
17        return _fs["token"]
18    with _fs_lock:
19        if _fs["token"] and _fs["expire_at"] - time.time() > 300:
20            return _fs["token"]
21        r = httpx.post(FS_TOKEN_URL, json={
22            "app_id": APP_ID, "app_secret": APP_SECRET}, timeout=10)
23        data = r.json()
24        if data.get("code") != 0:
25            raise RuntimeError(f"获取 tenant_access_token 失败：{data}")
26        _fs["token"] = data["tenant_access_token"]
27        _fs["expire_at"] = now + data["expire"]     # 通常 7200 秒
28        return _fs["token"]

1SEND_URL = "https://open.feishu.cn/open-apis/im/v1/messages"
2
3def send_to_chat(chat_id: str, card: dict, receive_id_type: str = "chat_id") -> str:
4    r = httpx.post(SEND_URL, params={"receive_id_type": receive_id_type},
5        headers={"Authorization": f"Bearer {get_tenant_access_token()}"},
6        json={"receive_id": chat_id, "msg_type": "interactive",
7              "content": json.dumps(card, ensure_ascii=False)},   # 必须字符串化
8        timeout=10).json()
9    return r["data"]["message_id"]
10
11def send_placeholder(chat_id: str) -> str:
12    card = {"config": {"wide_screen_mode": True},
13            "header": {"template": "grey",
14                       "title": {"tag": "plain_text", "content": "豆包正在思考…"}},
15            "elements": [{"tag": "div",
16                          "text": {"tag": "lark_md", "content": "正在调用豆包 1.5 Pro，请稍候"}}]}
17    return send_to_chat(chat_id, card)
18
19def update_card(message_id: str, card: dict):
20    """PATCH 覆盖原卡片，用户看到的是同一条消息「长出」答案"""
21    return httpx.patch(f"{SEND_URL}/{message_id}",
22        headers={"Authorization": f"Bearer {get_tenant_access_token()}"},
23        json={"content": json.dumps(card, ensure_ascii=False)}, timeout=10).json()

1import os, json as _json
2import lark_oapi as lark
3from lark_oapi.api.im.v1 import *
4
5def on_receive(data: P2ImMessageReceiveV1) -> None:
6    msg = data.event.message
7    if msg.message_type != "text":        # 忽略图片、表情、系统消息
8        return
9    question = _json.loads(msg.content).get("text", "").strip()
10    if not question:
11        return
12    ep = route_endpoint(question)         # 选接入点
13    answer, tokens = ask_doubao(question, ep)
14    card = build_copy_card(question, answer, 0, tokens, ep, qid=msg.message_id)
15
16    # 用 message_id 做「回复」，消息挂在原消息下面，群里不会刷屏
17    client.im.v1.message.reply(ReplyMessageRequest.builder()
18        .message_id(msg.message_id)
19        .request_body(ReplyMessageRequestBody.builder()
20            .msg_type("interactive")
21            .content(_json.dumps(card, ensure_ascii=False)).build())
22        .build())
23
24handler = lark.EventDispatcherHandler.builder("", "") \
25    .register_p2_im_message_receive_v1(on_receive).build()
26client = lark.ws.Client(os.environ["FEISHU_APP_ID"], os.environ["FEISHU_APP_SECRET"],
27                        event_handler=handler, log_level=lark.LogLevel.INFO)
28client.start()

1@app.post("/feishu/event")
2async def feishu_event(req: Request):
3    body = await req.json()
4    if "challenge" in body:                      # 1. URL 校验，1 秒内返回
5        return {"challenge": body["challenge"]}
6    if "encrypt" in body:                        # 2. 配了 Encrypt Key 时是密文
7        body = decrypt(body["encrypt"], os.environ["FEISHU_ENCRYPT_KEY"])
8    if body.get("header", {}).get("event_type") == "im.message.receive_v1":
9        asyncio.create_task(handle_message(body["event"]))   # 异步，别阻塞
10    return {"code": 0}

1import base64, hashlib
2from Crypto.Cipher import AES      # pip install pycryptodome
3
4def decrypt(encrypt_b64: str, encrypt_key: str) -> dict:
5    """飞书 Encrypt Key 是 43 位字符串，SHA256 后取前 32 字节作密钥"""
6    key = hashlib.sha256(encrypt_key.encode()).digest()[:32]
7    raw = base64.b64decode(encrypt_b64)
8    iv, cipher_text = raw[:16], raw[16:]           # 前 16 字节是 IV
9    plain = AES.new(key, AES.MODE_CBC, iv).decrypt(cipher_text)
10    return _json.loads(plain[:-plain[-1]].decode("utf-8"))    # 去 PKCS7 填充

1第 1 天：可用范围只放自己，单聊自测
2第 2 天：拉 3 人测试群，验证 @、私聊、卡片按钮
3第 3 天：放开到 20 人小群，观察 token 消耗与响应时长
4第 5 天：全部门放开，群里置顶「机器人使用说明」

1- [x] 密钥与接入点 ID 全在环境变量里，git status 看不到 .env
2- [x] 确认 model 字段填的是 ep- 开头的接入点 ID 而不是模型名
3- [x] 连续发 100 条测试消息，没有触发飞书限流
4- [x] 断网 10 秒再恢复，长连接能自动重连
5- [x] 卡片按钮点下去都有正确回传
6- [x] 方舟控制台设了用量告警

1@豆包 1.5 Pro 助手
2给这场直播写 3 条标题，产品是「便携咖啡机」，受众是 25-35 岁上班族。
3要求：一条悬念型、一条直给型、一条情绪型，每条不超过 20 字。

1@豆包 1.5 Pro 助手
2把这段竞品推文压缩成 150 字摘要，按「他们做了什么 / 目标人群 / 
3我们可以怎么应对」三段输出，不要复述原文。

1@豆包 1.5 Pro 助手
2下面这段用户反馈，请判断：1）属于 P0/P1/P2 哪一级；2）应该转给哪个组；
33）给用户的一句标准回复。
4反馈内容：支付页面点了没反应，反复试了五次都不行，安卓机型。

1@豆包 1.5 Pro 助手
2这是本周数据：新增用户 1,240（上周 1,510）、次日留存 31%（上周 34%）、
3付费转化 2.1%（上周 2.4%）。请用「变化 + 可能原因 + 建议动作」的格式，
4给出 3 条观察，不要编造我们没有的数据。

1阶段 1（入门）：群自定义机器人 + 加签，能把豆包的回答推进群里      ← 你现在在这里
2阶段 2（进阶）：建推理接入点，搞懂 ep- ID 与模型名的关系
3阶段 3（高级）：交互卡片 + 占位卡 + 异步更新，把感知延迟压到 0.3 秒
4阶段 4（专家）：自建应用 + 长连接事件订阅 + 双接入点成本路由
5阶段 5（架构）：Webhook 回调 + 多副本 + KMS 密钥管理 + 接入点灰度