【Agent从入门到实践】20 LLM的基础使用：API调用（OpenAI、国产大模型），程序员快速上手

人工智能AI技术2026-01-22 9:41

文章目录

目前国内还是很缺AI人才的，希望更多人能真正加入到AI行业，共同促进行业进步。想要系统学习AI知识的朋友可以看看我的教程http://blog.csdn.net/jiangjunshow，教程通俗易懂，风趣幽默，从深度学习基础原理到各领域实战应用都有讲解。

一、前置准备：3步搞定API调用前提

在写代码之前，得先做好3件事，就像开车前要先拿驾照、加油一样：

1. 申请API密钥（核心凭证）

API密钥是你调用LLM的"身份证"，没有它，LLM服务器不认识你，会直接拒绝请求。

（1）OpenAI API密钥申请
  • 步骤：
    1. 访问官网：https://platform.openai.com/（需要科学上网）
    2. 注册/登录账号（用邮箱即可）
    3. 右上角头像 → View API keys → Create new secret key
    4. 复制密钥（只显示一次，一定要保存好，丢了只能重新创建）
  • 注意：OpenAI有免费额度（新用户送几美元），用完后需要绑定信用卡付费（支持国内信用卡）
（2）国产大模型API密钥申请（以通义千问为例）
  • 步骤：
    1. 访问阿里云百炼平台：https://dashscope.console.aliyun.com/
    2. 注册/登录阿里云账号（国内手机号即可）
    3. 左侧"API-KEY管理" → 创建API-KEY
    4. 复制密钥（可以创建多个，方便不同项目使用）
  • 优势：不用科学上网，支持国内网络，有免费调用额度（比如通义千问免费额度能满足开发测试）
（3）其他国产大模型申请入口

2. 安装必要依赖（Python库）

不管调用哪个LLM的API，都需要用HTTP请求库，推荐用httpx（现代替代requests，支持同步+异步），部分大模型有官方SDK，也可以直接安装：

bash 复制代码 
# 基础依赖（所有大模型都需要）
pip install httpx python-dotenv

# OpenAI官方SDK（推荐，比直接写HTTP请求更简单）
pip install openai

# 通义千问官方SDK（阿里云百炼）
pip install dashscope

# 文心一言官方SDK（百度千帆）
pip install qianfan

# 智谱清言官方SDK
pip install zhipuai

3. 管理密钥（安全第一，别硬编码！）

绝对不要把API密钥直接写在代码里（比如api_key = "sk-xxxxxx"），万一代码泄露，别人会盗用你的额度甚至产生高额费用！

推荐用python-dotenv管理：

  1. 在项目根目录创建.env文件；
  2. 把密钥写在文件里（格式：密钥名=密钥值）；
  3. 代码中用os.getenv()读取。

示例.env文件：

env 复制代码 
# OpenAI密钥
OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

# 通义千问密钥
DASHSCOPE_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

# 文心一言密钥
QIANFAN_API_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
QIANFAN_SECRET_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

二、核心原理：LLM API调用的本质（一句话搞懂）

不管是哪个大模型的API，调用逻辑都一样，本质是：
你通过HTTP请求（POST为主），把"问题/指令"发给大模型服务器，服务器处理后，返回"生成的文本"

就像你发微信消息给朋友：

  • 你 → 发消息（请求）："帮我写一段奶茶推荐文案"
  • 朋友 → 回消息（响应）："推荐青提茉莉奶茶，少糖少冰，清爽解渴～"

LLM API的请求/响应格式有固定规范：

  • 请求：必须带"模型名""消息列表""API密钥"，可选"温度""最大生成长度"等参数；
  • 响应：返回"生成的文本""消耗的token数""完成状态"等信息。

三、实战1：调用OpenAI API（GPT-4o/GPT-3.5-turbo）

OpenAI的API是行业标杆，接口设计简洁，支持的功能最多（比如流式输出、函数调用、多模态），咱们先从它入手，掌握基础用法。

1. 同步调用（最基础，等待完整响应）

适合不需要实时反馈的场景（比如生成报告、处理文本）。

python 复制代码 
import os
from dotenv import load_dotenv
from openai import OpenAI  # 官方SDK（v1+ 最新版本）

# 加载.env文件中的密钥
load_dotenv()
api_key = os.getenv("OPENAI_API_KEY")

# 初始化客户端（核心步骤）
client = OpenAI(
    api_key=api_key,
    timeout=30  # 超时时间，避免卡壳（重要！）
)

def openai_sync_call(user_input: str) -> str:
    """
    同步调用OpenAI API
    :param user_input: 用户输入（问题/指令）
    :return: 大模型生成的文本
    """
    try:
        # 发送请求（核心API调用）
        response = client.chat.completions.create(
            model="gpt-3.5-turbo",  # 模型名：gpt-3.5-turbo（性价比高）/ gpt-4o（功能强）
            messages=[
                # 系统消息：定义大模型角色和规则
                {"role": "system", "content": "你是一个友好的奶茶推荐师，语言简短亲切，给出具体甜度和冰量建议。"},
                # 用户消息：用户的实际需求
                {"role": "user", "content": user_input}
            ],
            temperature=0.7,  # 随机性：0~1，0=严谨，1=创意
            max_tokens=300,  # 最大生成长度（包含输入和输出）
            top_p=0.9,  # 核采样：0~1，值越小，生成越集中
            stop=None,  # 停止符：遇到指定字符停止生成（比如["。", "！"]）
            user="xiaoming"  # 可选：标记用户ID，方便OpenAI统计和排查问题
        )

        # 解析响应（提取生成的文本）
        generated_text = response.choices[0].message.content.strip()
        # 可选：获取token消耗（方便控制成本）
        prompt_tokens = response.usage.prompt_tokens
        completion_tokens = response.usage.completion_tokens
        total_tokens = response.usage.total_tokens

        print(f"📊 Token消耗：输入{prompt_tokens} + 输出{completion_tokens} = 总计{total_tokens}")
        return generated_text

    except Exception as e:
        print(f"❌ 调用失败：{str(e)}")
        return "抱歉，生成失败，请稍后再试～"

# 测试
if __name__ == "__main__":
    user_input = "夏天喝，要清爽、少糖、少冰，推荐一款奶茶"
    result = openai_sync_call(user_input)
    print(f"\n✨ 大模型回复：{result}")

2. 流式调用（实时输出，类似ChatGPT官网体验）

适合需要实时反馈的场景（比如聊天机器人、Agent交互），用户不用等完整响应，就能看到内容一点点生成。

python 复制代码 
import os
from dotenv import load_dotenv
from openai import OpenAI

load_dotenv()
api_key = os.getenv("OPENAI_API_KEY")
client = OpenAI(api_key=api_key, timeout=30)

def openai_stream_call(user_input: str):
    """流式调用OpenAI API（实时输出）"""
    try:
        response = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": "你是一个友好的奶茶推荐师，语言简短亲切"},
                {"role": "user", "content": user_input}
            ],
            temperature=0.7,
            stream=True  # 开启流式输出（关键！）
        )

        print("✨ 大模型回复：", end="")
        generated_text = ""
        # 逐块接收响应并输出
        for chunk in response:
            if chunk.choices[0].delta.content:  # 过滤空内容
                chunk_text = chunk.choices[0].delta.content
                generated_text += chunk_text
                print(chunk_text, end="", flush=True)  # flush=True 实时刷新
        print("\n")
        return generated_text

    except Exception as e:
        print(f"\n❌ 调用失败：{str(e)}")
        return "抱歉，生成失败，请稍后再试～"

# 测试
if __name__ == "__main__":
    user_input = "夏天喝，要清爽、少糖、少冰，推荐一款奶茶"
    openai_stream_call(user_input)

3. 关键参数说明（调优大模型输出的核心）

上面代码中几个重要参数，直接影响大模型的输出效果，一定要搞懂：

  • model：模型名称，OpenAI常用：
    • gpt-3.5-turbo：性价比最高，适合大部分场景，响应快、价格便宜；
    • gpt-4o：功能最强，支持多模态（文本+图片）、更长上下文，适合复杂任务（比如Agent决策）；
    • gpt-4o-mini：轻量版GPT-4o，价格比3.5稍高，但性能更强，平衡了成本和效果。
  • temperature：随机性控制（0~1）：
    • 0.1~0.3：输出严谨、稳定，适合需要准确结果的场景（比如数据分析、代码生成）；
    • 0.7~0.9：输出有创意、多样化，适合需要灵感的场景（比如文案生成、故事创作）。
  • max_tokens：最大生成长度（输入+输出的总token数）：
    • 1token≈0.75个英文单词，≈0.5个中文汉字；
    • gpt-3.5-turbo最大支持16384token，gpt-4o最大支持128000token；
    • 建议根据场景设置（比如短对话设300，长文本生成设2000），避免超出限制。
  • messages：消息列表，必须是包含role和content的字典列表：
    • role可选值：system（系统指令）、user（用户输入）、assistant（大模型历史回复）；
    • 作用：通过多轮消息上下文，让大模型理解对话历史（比如Agent的多轮交互）。

四、实战2：调用国产大模型API（以通义千问为例）

国产大模型的API调用逻辑和OpenAI几乎一致，只是"模型名""密钥参数""SDK用法"有细微差异。咱们以通义千问为例，其他国产模型（文心一言、智谱清言）的用法会在后面补充。

1. 同步调用（通义千问）

python 复制代码 
import os
from dotenv import load_dotenv
import dashscope  # 通义千问官方SDK（阿里云百炼）
from dashscope import Generation

# 加载密钥（通义千问的SDK需要设置环境变量或直接传入）
load_dotenv()
dashscope.api_key = os.getenv("DASHSCOPE_API_KEY")

def tongyi_sync_call(user_input: str) -> str:
    """同步调用通义千问API"""
    try:
        response = Generation.call(
            model="qwen-turbo",  # 通义千问常用模型：qwen-turbo（性价比高）/ qwen-max（旗舰版）
            messages=[
                {"role": "system", "content": "你是一个友好的奶茶推荐师，语言简短亲切，给出具体甜度和冰量建议。"},
                {"role": "user", "content": user_input}
            ],
            temperature=0.7,
            max_tokens=300,
            top_p=0.9,
            result_format="message"  # 输出格式：message（推荐）/ text
        )

        # 解析响应（通义千问的响应格式和OpenAI类似）
        if response.status_code == 200:
            generated_text = response.output.choices[0].message.content.strip()
            # 通义千问的token消耗需要从响应头提取（可选）
            prompt_tokens = response.usage.input_tokens
            completion_tokens = response.usage.output_tokens
            print(f"📊 Token消耗：输入{prompt_tokens} + 输出{completion_tokens} = 总计{prompt_tokens+completion_tokens}")
            return generated_text
        else:
            print(f"❌ 调用失败：{response.code} - {response.message}")
            return "抱歉，生成失败，请稍后再试～"

    except Exception as e:
        print(f"❌ 调用失败：{str(e)}")
        return "抱歉，生成失败，请稍后再试～"

# 测试
if __name__ == "__main__":
    user_input = "夏天喝，要清爽、少糖、少冰，推荐一款奶茶"
    result = tongyi_sync_call(user_input)
    print(f"\n✨ 通义千问回复：{result}")

2. 流式调用（通义千问）

python 复制代码 
import os
from dotenv import load_dotenv
import dashscope
from dashscope import Generation

load_dotenv()
dashscope.api_key = os.getenv("DASHSCOPE_API_KEY")

def tongyi_stream_call(user_input: str):
    """流式调用通义千问API"""
    try:
        response = Generation.call(
            model="qwen-turbo",
            messages=[
                {"role": "system", "content": "你是一个友好的奶茶推荐师，语言简短亲切"},
                {"role": "user", "content": user_input}
            ],
            temperature=0.7,
            stream=True,  # 开启流式输出
            result_format="message"
        )

        print("✨ 通义千问回复：", end="")
        generated_text = ""
        for chunk in response:
            if chunk.status_code == 200 and chunk.output.choices[0].message.content:
                chunk_text = chunk.output.choices[0].message.content
                generated_text += chunk_text
                print(chunk_text, end="", flush=True)
        print("\n")
        return generated_text

    except Exception as e:
        print(f"\n❌ 调用失败：{str(e)}")
        return "抱歉，生成失败，请稍后再试～"

# 测试
if __name__ == "__main__":
    user_input = "夏天喝，要清爽、少糖、少冰，推荐一款奶茶"
    tongyi_stream_call(user_input)

五、实战3：其他国产大模型API调用（文心一言、智谱清言）

1. 文心一言API调用（百度千帆）

python 复制代码 
import os
from dotenv import load_dotenv
from qianfan import ChatCompletion  # 文心一言官方SDK

load_dotenv()
# 文心一言需要API_KEY和SECRET_KEY
api_key = os.getenv("QIANFAN_API_KEY")
secret_key = os.getenv("QIANFAN_SECRET_KEY")

def baidu_sync_call(user_input: str) -> str:
    """同步调用文心一言API"""
    try:
        client = ChatCompletion(
            api_key=api_key,
            secret_key=secret_key,
            timeout=30
        )

        response = client.do(
            model="ernie-3.5-turbo",  # 文心一言常用模型：ernie-3.5-turbo（性价比高）
            messages=[
                {"role": "system", "content": "你是一个友好的奶茶推荐师，语言简短亲切"},
                {"role": "user", "content": user_input}
            ],
            temperature=0.7,
            max_tokens=300
        )

        if response["code"] == 200:
            generated_text = response["result"].strip()
            prompt_tokens = response["usage"]["prompt_tokens"]
            completion_tokens = response["usage"]["completion_tokens"]
            print(f"📊 Token消耗：输入{prompt_tokens} + 输出{completion_tokens} = 总计{prompt_tokens+completion_tokens}")
            return generated_text
        else:
            print(f"❌ 调用失败：{response['code']} - {response['message']}")
            return "抱歉，生成失败，请稍后再试～"

    except Exception as e:
        print(f"❌ 调用失败：{str(e)}")
        return "抱歉，生成失败，请稍后再试～"

# 测试
if __name__ == "__main__":
    user_input = "夏天喝，要清爽、少糖、少冰，推荐一款奶茶"
    result = baidu_sync_call(user_input)
    print(f"\n✨ 文心一言回复：{result}")

2. 智谱清言API调用

python 复制代码 
import os
from dotenv import load_dotenv
from zhipuai import ZhipuAI  # 智谱清言官方SDK

load_dotenv()
api_key = os.getenv("ZHIPU_API_KEY")  # 智谱清言的API_KEY，申请后在平台获取

def zhipu_sync_call(user_input: str) -> str:
    """同步调用智谱清言API"""
    try:
        client = ZhipuAI(api_key=api_key, timeout=30)

        response = client.chat.completions.create(
            model="glm-4",  # 智谱清言常用模型：glm-4（旗舰版）/ glm-3-turbo（性价比高）
            messages=[
                {"role": "system", "content": "你是一个友好的奶茶推荐师，语言简短亲切"},
                {"role": "user", "content": user_input}
            ],
            temperature=0.7,
            max_tokens=300
        )

        generated_text = response.choices[0].message.content.strip()
        prompt_tokens = response.usage.prompt_tokens
        completion_tokens = response.usage.completion_tokens
        print(f"📊 Token消耗：输入{prompt_tokens} + 输出{completion_tokens} = 总计{prompt_tokens+completion_tokens}")
        return generated_text

    except Exception as e:
        print(f"❌ 调用失败：{str(e)}")
        return "抱歉，生成失败，请稍后再试～"

# 测试
if __name__ == "__main__":
    user_input = "夏天喝，要清爽、少糖、少冰，推荐一款奶茶"
    result = zhipu_sync_call(user_input)
    print(f"\n✨ 智谱清言回复：{result}")

六、通用封装：一个函数调用所有LLM（Agent开发必备）

在Agent开发中，可能需要根据场景切换不同的大模型（比如国内用户用通义千问，海外用户用OpenAI）。咱们可以写一个通用封装函数，统一调用接口，后续切换模型只需要改参数，不用改业务代码！

python 复制代码 
import os
from dotenv import load_dotenv

# 加载所有大模型的密钥
load_dotenv()

# 导入各个大模型的SDK
try:
    from openai import OpenAI as OpenAIClient
except ImportError:
    print("⚠️  未安装openai SDK，无法使用OpenAI模型")

try:
    import dashscope
    from dashscope import Generation as TongyiClient
    dashscope.api_key = os.getenv("DASHSCOPE_API_KEY")
except ImportError:
    print("⚠️  未安装dashscope SDK，无法使用通义千问模型")

try:
    from qianfan import ChatCompletion as BaiduClient
except ImportError:
    print("⚠️  未安装qianfan SDK，无法使用文心一言模型")

class LLMClient:
    """通用LLM客户端，支持多模型切换"""
    def __init__(self, model_type: str = "openai"):
        """
        初始化客户端
        :param model_type: 模型类型：openai / tongyi / baidu / zhipu
        """
        self.model_type = model_type
        self.client = self._init_client()

    def _init_client(self):
        """初始化对应模型的客户端"""
        if self.model_type == "openai":
            return OpenAIClient(
                api_key=os.getenv("OPENAI_API_KEY"),
                timeout=30
            )
        elif self.model_type == "tongyi":
            return TongyiClient
        elif self.model_type == "baidu":
            return BaiduClient(
                api_key=os.getenv("QIANFAN_API_KEY"),
                secret_key=os.getenv("QIANFAN_SECRET_KEY"),
                timeout=30
            )
        elif self.model_type == "zhipu":
            from zhipuai import ZhipuAI
            return ZhipuAI(
                api_key=os.getenv("ZHIPU_API_KEY"),
                timeout=30
            )
        else:
            raise ValueError(f"不支持的模型类型：{self.model_type}")

    def chat(self, user_input: str, system_prompt: str = None) -> str:
        """
        通用聊天接口
        :param user_input: 用户输入
        :param system_prompt: 系统提示词
        :return: 生成的文本
        """
        system_prompt = system_prompt or "你是一个友好的助手，语言简洁明了。"
        messages = [
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": user_input}
        ]

        try:
            if self.model_type == "openai":
                response = self.client.chat.completions.create(
                    model="gpt-3.5-turbo",
                    messages=messages,
                    temperature=0.7,
                    max_tokens=300
                )
                return response.choices[0].message.content.strip()

            elif self.model_type == "tongyi":
                response = self.client.call(
                    model="qwen-turbo",
                    messages=messages,
                    temperature=0.7,
                    max_tokens=300,
                    result_format="message"
                )
                return response.output.choices[0].message.content.strip()

            elif self.model_type == "baidu":
                response = self.client.do(
                    model="ernie-3.5-turbo",
                    messages=messages,
                    temperature=0.7,
                    max_tokens=300
                )
                return response["result"].strip()

            elif self.model_type == "zhipu":
                response = self.client.chat.completions.create(
                    model="glm-4",
                    messages=messages,
                    temperature=0.7,
                    max_tokens=300
                )
                return response.choices[0].message.content.strip()

        except Exception as e:
            print(f"❌ {self.model_type}调用失败：{str(e)}")
            return "抱歉，生成失败，请稍后再试～"

# 测试：切换不同模型
if __name__ == "__main__":
    # 1. 使用OpenAI
    openai_client = LLMClient(model_type="openai")
    print("=== OpenAI 回复 ===")
    print(openai_client.chat("夏天喝，要清爽、少糖、少冰，推荐一款奶茶"))

    # 2. 使用通义千问
    tongyi_client = LLMClient(model_type="tongyi")
    print("\n=== 通义千问 回复 ===")
    print(tongyi_client.chat("夏天喝，要清爽、少糖、少冰，推荐一款奶茶"))

    # 3. 使用文心一言
    baidu_client = LLMClient(model_type="baidu")
    print("\n=== 文心一言 回复 ===")
    print(baidu_client.chat("夏天喝，要清爽、少糖、少冰，推荐一款奶茶"))

七、常见问题&避坑指南（2025最新实战经验）

1. 密钥错误（最常见）

  • 报错表现：Invalid API key / API_KEY不存在
  • 解决方法：
    • 检查密钥是否复制正确（有没有多空格、少字符）；
    • 检查.env文件的密钥名是否和代码中的os.getenv()一致（比如文件里是OPENAI_KEY，代码里是OPENAI_API_KEY）；
    • 检查密钥是否过期（部分国产大模型的密钥有有效期，需要重新生成）。

2. 网络问题

  • 报错表现：Connection timeout / 无法连接服务器
  • 解决方法：
    • OpenAI需要科学上网，国内网络无法直接访问；
    • 国产大模型（通义千问、文心一言）不需要科学上网，确保网络通畅；
    • 增加超时时间（比如timeout=30），避免网络波动导致的超时。

3. 模型不存在/无权限

  • 报错表现：Model not found / 无权限调用该模型
  • 解决方法：
    • 检查模型名是否正确（比如通义千问的模型名是qwen-turbo，不是gpt-3.5-turbo）；
    • 确认该模型是否在你的权限范围内（部分旗舰模型需要申请开通，或付费后才能使用）；
    • 查看大模型官网的"模型列表"，确认最新的模型名（模型可能会迭代更新）。

4. Token超限

  • 报错表现：Maximum context length exceeded / token长度超过限制
  • 解决方法：
    • 减少max_tokens的值（比如从2000改成500）；
    • 精简输入文本（比如删除不必要的上下文信息）；
    • 选择支持更长上下文的模型（比如gpt-4o支持128k token，qwen-max支持8k/32k token）。

5. 调用频率超限

  • 报错表现：Rate limit exceeded / 调用频率过高
  • 解决方法：
    • 降低调用频率（比如多线程调用时增加间隔）；
    • 查看大模型官网的"调用限制"，了解免费额度的QPS（每秒调用次数）；
    • 付费升级套餐，提高调用频率限制。

6. 费用问题（避免超额扣费）

  • 避坑建议：
    • 开发测试时用"轻量版模型"（比如gpt-3.5-turbo、qwen-turbo），价格便宜；
    • 设置max_tokens上限，避免生成超长文本导致高额费用；
    • 定期查看大模型平台的"费用账单"，监控消耗情况；
    • 部分平台支持设置"消费限额"，超过限额会自动停止调用（强烈推荐）。

八、总结：LLM API调用的核心逻辑

其实不管是OpenAI还是国产大模型，API调用的核心逻辑都是"统一的请求格式 + 对应的SDK调用 + 响应解析"，记住这3点，就能快速上手任何LLM：

  1. 请求格式统一 ：都是通过messages参数传递"系统指令+用户输入"，通过temperature/max_tokens等参数控制输出；
  2. SDK用法类似 ：都需要初始化客户端（传入密钥），调用chat.completions.create()或类似方法；
  3. 响应解析简单 ：都能从choices[0].message.content（或类似字段）中提取生成的文本。

对咱们Agent开发来说，LLM API调用是"大脑"的基础------只有先学会调用LLM，才能让Agent具备"理解、推理、决策"的能力。接下来，你可以把今天的代码整合到之前的Agent框架中，让Agent真正"活"起来！

相关推荐
云上凯歌2 小时前
01_AI工具平台项目概述.md
人工智能·python·uni-app
R-sz2 小时前
app登录接口实现，基于JWT的APP登录认证系统实现方案
java·开发语言·python
WangYaolove13142 小时前
基于图像取证技术研究与实现（源码+文档）
python·django·毕业设计·源码·计算机源码
qunaa01012 小时前
【深度学习】基于Sparse-RCNN的多类别蘑菇物种识别与检测系统_2
人工智能·深度学习·目标跟踪
薛不痒2 小时前
深度学习的补充
人工智能·深度学习
程序员敲代码吗2 小时前
用Python监控系统日志并发送警报
jvm·数据库·python
qwerasda1238522 小时前
YOLO13-SEG-RFAConv：隧道围岩病理缺陷识别的改进方法与底层逻辑
python
_codemonster2 小时前
分布式深度学习训练框架Horovod
人工智能·分布式·深度学习
数智工坊2 小时前
【MobileVIT论文解读】打破 CNN 与 ViT 壁垒：MobileViT 如何重塑移动端视觉模型？
人工智能·神经网络·cnn
热门推荐
01GitHub 镜像站点02OpenCode 入门教程：介绍 · 安装 · 配置第三方 API (如 Claude)03在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）042025 Telegram 最新免费社工库机器人（LetsTG可[特殊字符]）搭建指南（含 Python 脚本）05AI 规范驱动开发“三剑客”深度对比：Spec-Kit、Kiro 与 OpenSpec 实战指南06UV安装并设置国内源07BongoCat - 跨平台键盘猫动画工具08安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）09Claude Code Skills 实用使用手册10Linux下V2Ray安装配置指南