当 AI 学会查行情：TickDB SKILL 协议的技术解剖

普通用户说"帮我看看英伟达最近一周的走势"，AI 助手在几秒内完成了三个动作：理解意图、调出历史K线数据、将结果以图表形式返回。这不是魔法，背后是一套让 AI 理解"行情查询"这件事的协议——SKILL。

市面上有大量自然语言转 API 调用的方案，但大多数停留在"给 AI 扔一段 system prompt" 的粗糙阶段。参数靠猜，返回靠试，多轮对话一塌糊涂。SKILL 协议的设计目标不同：它不是提示词工程，而是一套结构化的规范，让 AI 能够精确理解 TickDB 提供了哪些数据能力、如何调用、返回什么格式，以及在多轮对话中如何维护上下文。

本文从设计理念出发，完整拆解 SKILL 协议的核心文件 skill.md 的结构、Function Calling 的定义规范，以及多轮对话下的上下文管理机制。适合对 AI 工具集成、Function Calling 机制或数据 API 架构有深度兴趣的技术读者。

一、为什么需要 SKILL 协议

在讨论协议细节之前，先理解 SKILL 协议解决的根本问题。

传统的行情 API 调用链路是人 → 文档 → 代码 → API。开发者需要先读懂 API 文档，理解参数含义，找到正确的端点，然后写代码调用。这对人类来说是可行的，但对 AI 不友好——AI 没有"读文档理解参数"的能力，它的上下文窗口虽然大，但缺乏对隐式业务逻辑的理解。

举个例子。如果用户对 AI 说"帮我看看 AAPL 最近一个月的波动率"，在没有 SKILL 的情况下：

AI 可能会尝试调用 /quote 接口，但那只返回当前价格
AI 可能会猜 interval=1m，但不清楚这个参数的正确范围
AI 可能会忽略 adjusted 参数，导致复权数据和不复权数据混在一起

SKILL 协议的核心作用是消除歧义，提供精确的可调用接口清单。它将 TickDB 的每一个能力翻译成 AI 能够理解的函数定义，包含：函数名称、参数类型与约束、返回值格式、业务上下文说明。

这样一来，AI 在收到用户查询时，不再靠"猜"，而是直接查 SKILL 中的函数定义，找到最匹配的函数，填充参数，完成调用。这套机制在学术上被称为 Structured Tool Use，在工业界更常见的名字是 Function Calling。

二、`skill.md`：AI 的行情查询说明书

2.1 文件定位与设计原则

skill.md 是 SKILL 协议的核心文件，放在 TickDB 服务根路径下（http://skill.md/），AI 助手的 SDK 或中间件在初始化阶段会拉取并解析这份文件。

这份文件的设计遵循三个原则：

原则一：AI-first 表述。文件中不使用自然语言描述功能，而是用结构化的 JSON Schema 定义函数签名。每个函数描述（description）字段专门为 AI 而写，告诉 AI "什么时候应该调用这个函数"以及"如何理解返回的数据"。

原则二：精确的数据边界。SKILL 会明确标注每个接口支持的市场和数据类型。比如 kline 接口支持美股 10 年历史 K 线，但不支持 tick 级逐笔成交；trades 接口支持港股和数字货币，但不支持美股。这些边界会在函数定义的描述中精确体现，防止 AI 在错误的场景下调用错误的接口。

原则三：零外部依赖。一个完整的 SKILL 调用不依赖额外文档，AI 仅凭 skill.md 的内容就能完成从理解到调用的全流程。

2.2 文件结构总览

skill.md 的完整结构分为五大区块：

skill.md
├── meta          # 元信息：协议版本、支持的模型、联系方式
├── auth          # 鉴权方式：API Key 环境变量、请求头格式
├── functions[]   # 函数列表：每个函数的结构化定义
│   ├── name
│   ├── description
│   ├── parameters (JSON Schema)
│   └── returns (JSON Schema)
├── prompts       # 补充提示词：系统级指令，帮助 AI 正确理解上下文
└── examples[]    # 调用示例：典型查询的输入输出对

下面逐一展开每个区块。

2.3 Meta 元信息区块

{
  "meta": {
    "protocol_version": "1.0",
    "tickdb_version": ">=2.1.0",
    "supported_markets": ["US_STOCK", "HK_STOCK", "CRYPTO", "FOREX", "COMMODITY", "INDEX"],
    "ai_model_hint": "gpt-4o, claude-3.5-sonnet, gemini-2.0-flash",
    "contact": "[email protected]"
  }
}

meta 区块告诉 AI 两件关键事情：当前 TickDB 的能力覆盖哪些市场，以及这份 SKILL 文件适配哪些大语言模型。这看起来简单，但它的作用是防止 AI 在能力不匹配的条件下调用接口——例如当用户问"帮我看看人民币兑美元的即期汇率"时，AI 先检查 supported_markets 发现 FOREX 在列，才继续往下走。

ai_model_hint 字段的作用在多模态场景下更明显。不同的模型对 JSON Schema 的解析能力不同，有些模型对嵌套层级超过 3 层的 schema 解析不稳定，ai_model_hint 相当于一份兼容性提示，供 SDK 在运行时做兜底适配。

2.4 Auth 鉴权区块

{
  "auth": {
    "type": "api_key",
    "env_var": "TICKDB_API_KEY",
    "header": "X-API-Key",
    "warning": "Never expose API Key in any returned message or code snippet visible to end users"
  }
}

auth 区块定义鉴权方式。TickDB 使用标准的 API Key 认证，AI 在构造请求时需要从环境变量读取 TICKDB_API_KEY，并将值填入 HTTP Header 的 X-API-Key 字段。

这里值得注意的细节是 warning 字段。这不是写给人看的提示，而是 SKILL 协议的一部分——它会作为系统级指令注入到 AI 的推理过程中。AI 在返回结果时，会检查输出内容中是否包含 API Key 片段，若有则自动脱敏或拒绝输出。这是一个容易被忽略但至关重要的安全设计。

2.5 Functions 函数定义区块

Functions 是 skill.md 最核心的部分。每个函数定义包含五个子字段：

字段	类型	作用
`name`	字符串	函数唯一标识符，AI 调用的入口
`description`	字符串	AI-first 说明，告诉 AI 何时调用、含义是什么
`parameters`	JSON Schema	参数类型、约束条件、枚举值
`returns`	JSON Schema	返回值结构
`examples`	对象数组	典型调用示例（输入→输出）

以 K 线查询函数为例，完整的定义如下：

{
  "name": "get_kline",
  "description": "获取历史K线数据，适用于趋势分析、回测数据拉取和图表展示。当用户提及 '走势'、'K线'、'历史价格'、'过去N天' 等关键词时使用。注意：此接口返回已结束周期的历史K线，不适用于实时行情监控。实时监控请使用 subscribe_market_data。",
  "parameters": {
    "type": "object",
    "properties": {
      "symbol": {
        "type": "string",
        "pattern": "^[A-Z]{1,5}\\.(US|HK|CRYPTO)$",
        "description": "交易品种代码，使用市场前缀。例：AAPL.US, 0700.HK, BTC.USDT",
        "examples": ["AAPL.US", "0700.HK", "BTC.USDT"]
      },
      "interval": {
        "type": "string",
        "enum": ["1m", "5m", "15m", "30m", "1h", "4h", "1d", "1w"],
        "description": "K线周期。美股支持 1d/1w 及以上，港股/数字货币支持全部周期。"
      },
      "limit": {
        "type": "integer",
        "minimum": 1,
        "maximum": 1000,
        "default": 100,
        "description": "返回K线数量上限，默认100条。"
      },
      "adjusted": {
        "type": "boolean",
        "default": true,
        "description": "是否返回前复权数据。建议趋势分析使用 true，结算精度场景使用 false。"
      }
    },
    "required": ["symbol", "interval"]
  },
  "returns": {
    "type": "object",
    "properties": {
      "symbol": {"type": "string"},
      "interval": {"type": "string"},
      "data": {
        "type": "array",
        "items": {
          "type": "object",
          "properties": {
            "timestamp": {"type": "integer", "description": "Unix时间戳（毫秒）"},
            "open": {"type": "number"},
            "high": {"type": "number"},
            "low": {"type": "number"},
            "close": {"type": "number"},
            "volume": {"type": "number"}
          }
        }
      },
      "count": {"type": "integer", "description": "本次返回的数据条数"}
    }
  },
  "examples": [
    {
      "input": "英伟达最近一个月日线走势",
      "params": {"symbol": "NVDA.US", "interval": "1d", "limit": 30, "adjusted": true},
      "note": "AI 推导出 interval=1d（用户说'一个月'默认对应日线），limit=30，adjusted=true（趋势分析默认复权）"
    },
    {
      "input": "比特币最近一周每4小时的波动情况",
      "params": {"symbol": "BTC.USDT", "interval": "4h", "limit": 42},
      "note": "用户明确指定了 interval=4h，AI 按用户意图设置参数"
    }
  ]
}

这个函数定义中有几个细节值得展开。

参数约束的具体化。symbol 字段不只写"品种代码"，而是通过 pattern 定义了格式规范——^[A-Z]{1,5}\\.(US|HK|CRYPTO)$，AI 在构造参数时会严格校验格式，防止传入格式错误的参数导致 API 返回错误。

枚举值加描述。interval 字段的 enum 限制了可选值，同时在 description 中注明了不同市场的支持差异。AI 在处理"港股15分钟K线"和"美股15分钟K线"时，会根据市场类型判断这个请求是否合理。

examples 中的 note 字段是关键。普通 Function Calling 的 examples 通常只展示输入和输出，但 SKILL 协议的 examples 还包含一段 AI 推理过程的注释。这让 AI 不只是"照着示例填参数"，而是理解参数推导的逻辑。例如，当用户说"最近一个月"时，AI 需要推导出"30 条日线"；当用户没有明确指定是否复权时，AI 需要根据上下文（趋势分析 vs. 结算）做出合理默认。

三、Function Calling 的定义机制

3.1 从自然语言到结构化调用的映射流程

当用户对 AI 说"帮我看看特斯拉最近一周的走势"，SKILL 协议驱动下的 Function Calling 流程如下：

用户输入
    │
    ▼
意图识别 → 选择函数 get_kline
    │
    ▼
参数提取 → symbol=TESL.US? 不对，代码是 TSLA.US
    │         interval=? 用户说"一周"，默认 1d
    │         limit=? 一周日线约 7 条，但留余量取 10 条
    │         adjusted=? 趋势分析，默认 true
    │
    ▼
参数校验 → symbol 格式校验 → 通过
    │
    ▼
构造请求 → GET /v1/market/kline
    │         Headers: X-API-Key: {env:TICKDB_API_KEY}
    │         Params: symbol=TSLA.US&interval=1d&limit=10&adjusted=true
    │
    ▼
API 调用 → TickDB 服务器返回 JSON
    │
    ▼
结果格式化 → 文本/图表/表格，AI 自动选择最适合用户理解的形式

在这个流程中，SKILL 协议扮演的是中间翻译层的角色。它不改变 AI 的推理能力，但为 AI 提供了一套完整的信息源——函数定义、参数约束、返回格式、调用示例——让 AI 的推理有据可依。

3.2 参数推导的上下文推理

SKILL 协议中参数推导的智能化程度，取决于 description 和 examples 的设计质量。以下是几个典型的推导场景：

场景一：模糊时间范围

用户："最近走势怎么样"

AI 推理：

查 SKILL，没有指定具体时间段
查看 examples 中的注释，找到"趋势分析默认取近 30 条"的约定
设置 limit=30，interval 由 AI 根据市场特性选择（美股默认 1d）

场景二：反向推导

用户："我没有看到特斯拉的行情，你们支持港股吗？"

AI 推理：

先调用 get_kline 测试 TSLA.US，得到数据，说明美股可用
用户追问港股，AI 查 meta.supported_markets，发现 HK_STOCK 在列
调用 get_kline 测试 0700.HK（腾讯），返回成功
告知用户"港股支持，可查询 0700.HK 等"

场景三：矛盾检测

用户："帮我看 AAPL 1 分钟K线，走势分析"

AI 推理：

用户指定 interval=1m，符合 enum 约束
但 SKILL 的 description 注明"美股仅支持 1d/1w 及以上"
AI 检测到矛盾，回复："AAPL 属于美股市场，TickDB 目前不支持 1 分钟K线。美股支持的最小周期为 1d 级别。如需分钟级数据，可查询港股品种（如 0700.HK）或数字货币。"
提供替代方案，而非生硬报错

这种"矛盾检测 + 替代建议"的能力，是 SKILL 区别于普通 Function Calling 的关键。普通的 function schema 只能做参数校验，但无法告诉 AI"校验失败时应该怎么回应"；SKILL 的 description 中嵌入了业务逻辑，AI 能够生成更自然的用户体验。

3.3 批量查询的场景支持

当用户说"帮我对比英伟达、AMD、台积电最近三个月的走势"，这是一个批量查询场景。SKILL 协议通过以下机制支持：

# AI 识别出三个标的，构造批量参数
# 注意：实际实现取决于 SDK 版本，以下为逻辑示意

def batch_kline_query(symbols, interval="1d", months=3):
    """
    批量K线查询包装函数
    实际使用时需根据 SDK 文档选择批量接口或循环调用
    """
    # 估算数据量：3个月 ≈ 90 条日线
    # 每个标的单独调用
    results = []
    for symbol in symbols:
        params = {
            "symbol": symbol,
            "interval": interval,
            "limit": min(90, MAX_LIMIT),
            "adjusted": True
        }
        # 调用 get_kline
        result = skill_call("get_kline", params)
        results.append(result)
    
    return align_timestamps(results)  # 时间轴对齐后返回

SKILL 的 functions 列表中通常包含一个 batch_get_kline 函数，用于高效处理多标的查询。AI 会自动选择批量接口而非串行调用，提升响应速度。

四、多轮对话的上下文管理

4.1 对话上下文的生命周期

多轮对话是 SKILL 协议区别于单次 Function Calling 的核心挑战。在单次调用中，AI 只处理一个用户意图；但在多轮对话中，用户可能在前一轮的基础上追加条件、修改范围，或者追问细节。

SKILL 协议的多轮上下文管理分为三个层次：

第一层：会话级上下文。整个对话会话中，AI 维护一个上下文对象，包含：用户已查询的标的列表、已获取的数据范围、当前活跃的函数调用状态。当用户说"那换成日线看看"时，AI 知道这是在修改上一轮的 interval 参数，而不是发起新的查询。

{
  "session_context": {
    "active_symbols": ["NVDA.US"],
    "current_interval": "1h",
    "retrieved_range": "最近24小时",
    "last_function_call": "get_kline",
    "modification_intent": "interval change to 1d"
  }
}

第二层：标的级上下文。当用户说"英伟达和AMD对比看看"，AI 维护两个标的的上下文，允许后续追问"AMD 最近一周的走势"而不需要重复指定标的。

第三层：数据级上下文。当 AI 已经拉取了某标的的 K 线数据，后续的问题（"最高点是什么时候"、"RSI 指标是多少"）可以直接基于内存中的数据计算，而不需要重新调用 API。

4.2 上下文状态的 SKILL 标记

SKILL 协议通过 prompts 区块为多轮对话提供系统级指令：

{
  "prompts": {
    "system_instruction": "当用户提及'那'、'换成'、'改为'等指代词时，优先从上一轮对话上下文推断具体标的和参数。",
    "context_maintenance": "维护标的列表(symols)和参数状态(last_params)，在参数修改场景中保留未变更字段。",
    "fallback_strategy": "当上下文不足以推断用户意图时，询问澄清而非猜测。例如：'您想要对比的是哪些标的？'"
  }
}

这段配置看起来像普通的提示词工程，但它被嵌在 skill.md 中，作为 SKILL 协议的一部分，确保任何实现了 SKILL SDK 的 AI 助手都遵循同一套上下文管理逻辑。

4.3 多轮场景示例

第一轮

用户：英伟达最近一个月走势怎么样

AI：调用 get_kline(symbol=NVDA.US, interval=1d, limit=30, adjusted=true)

返回数据后，AI 以图表形式展示走势。

第二轮

用户：换成AMD看看

AI：

从上下文提取 interval=1d, limit=30, adjusted=true（未变更参数）
将 symbol 替换为 AMD.US
调用 get_kline(symbol=AMD.US, interval=1d, limit=30, adjusted=true)

第三轮

用户：帮我对比一下两者

AI：

从上下文提取已查询的两个标的 NVDA.US 和 AMD.US
调用 batch_get_kline 拉取两者数据
对齐时间轴，计算涨跌幅差值，返回对比图表

第四轮

用户：最近的成交量有没有异常

AI：

从上下文提取已拉取的 K 线数据（含 volume 字段）
计算最近 5 根 K 线的成交量均值和标准差
检测是否有单日成交量超过 2 倍标准差
标注异常日期，返回量化结果

这个场景展示了 SKILL 协议下多轮对话的递进逻辑：每一轮都在前一轮的基础上累积上下文，而不是重新理解整个对话。

五、SKILL 协议与普通 Function Calling 的对比

维度	普通 Function Calling	SKILL 协议
函数定义来源	开发者手动写 schema，需自行处理业务逻辑说明	结构化文件（`skill.md`）提供统一规范，含 AI-first 描述
参数约束表达	仅 JSON Schema 类型和枚举	Schema + 格式正则 + 市场支持说明 + 跨字段约束
多轮上下文	完全依赖 AI 模型记忆，容易丢失	会话级/标的级/数据级三层管理，SDK 自动维护
错误恢复策略	需开发者额外编写 prompt	协议内置矛盾检测 + 替代建议逻辑
安全脱敏	依赖系统 prompt 叮嘱	`auth.warning` 作为协议级指令强制注入
数据边界表达	隐含在描述文字中	在 `meta` 和每个函数的 `description` 中双重复制
调用示例	仅展示输入/输出	输入+参数+AI推理注释（`note`），让 AI 学会推导逻辑
协议版本控制	无	`meta.protocol_version` 支持版本校验和向前兼容

SKILL 协议的核心价值在于降低 AI 与数据 API 之间的耦合成本。普通 Function Calling 需要开发者在每一个函数定义中重复编写业务说明和边界约束，SKILL 协议通过标准化的文件结构，让这套信息成为可复用、可版本化的协议资产。

六、生产级集成示例

以下是 AI 助手通过 SKILL 协议查询行情的完整代码示例。代码包含鉴权、超时处理、错误处理和结果格式化，符合 TickDB 生产级调用规范：

import os
import json
import time
import random
import requests
from typing import Optional

# === SKILL 协议核心调用类 ===

class TickDBSKILL:
    """
    TickDB SKILL 协议客户端
    遵循 SKILL 协议 v1.0 规范
    """
    
    def __init__(self, api_key: Optional[str] = None):
        # ⚠️ API Key 必须从环境变量读取，切勿硬编码
        self.api_key = api_key or os.environ.get("TICKDB_API_KEY")
        if not self.api_key:
            raise ValueError(
                "API Key 未设置。请在环境中配置 TICKDB_API_KEY："
                "\n  export TICKDB_API_KEY=your_key_here"
            )
        self.base_url = "https://api.tickdb.ai/v1"
        self.headers = {
            "X-API-Key": self.api_key,
            "Content-Type": "application/json"
        }
        # 速率限制：10 请求/秒（免费层），SDK 自动处理 3001 限频
        self.request_count = 0
        self.last_reset = time.time()
    
    def _rate_limit_check(self):
        """速率限制检查：免费层 10 req/s"""
        elapsed = time.time() - self.last_reset
        if elapsed >= 1.0:
            self.request_count = 0
            self.last_reset = time.time()
        if self.request_count >= 10:
            time.sleep(1.0 - elapsed)
            self.request_count = 0
            self.last_reset = time.time()
        self.request_count += 1
    
    def _request_with_retry(self, method: str, endpoint: str, 
                            params: Optional[dict] = None, 
                            max_retries: int = 3) -> dict:
        """
        带指数退避的重试机制
        """
        base_delay = 1.0
        max_delay = 30.0
        
        for attempt in range(max_retries):
            try:
                self._rate_limit_check()
                
                response = requests.request(
                    method=method,
                    url=f"{self.base_url}{endpoint}",
                    headers=self.headers,
                    params=params,
                    timeout=(3.05, 10)  # 连接超时 3.05s，读取超时 10s
                )
                
                # 处理限频响应（code: 3001）
                if response.status_code == 429:
                    retry_after = int(response.headers.get("Retry-After", 5))
                    print(f"[SKILL] 触发限频，等待 {retry_after}s")
                    time.sleep(retry_after)
                    continue
                
                result = response.json()
                
                # 处理业务错误码
                code = result.get("code", 0)
                if code == 0:
                    return result.get("data", {})
                
                if code in (1001, 1002):
                    raise ValueError(
                        f"API Key 无效（code:{code}）。"
                        "请检查 TICKDB_API_KEY 是否正确。"
                    )
                if code == 2002:
                    raise KeyError(
                        f"交易品种不存在（code:{code}）。"
                        "请检查 symbol 格式，如 AAPL.US、0700.HK。"
                    )
                
                # 未知错误，触发重试
                raise RuntimeError(f"API 返回错误 code:{code} - {result.get('message')}")
                
            except requests.exceptions.Timeout:
                # 超时触发指数退避
                pass
            except requests.exceptions.ConnectionError:
                # 连接错误触发指数退避 + 抖动
                pass
            
            # 指数退避 + 抖动（避免惊群效应）
            if attempt < max_retries - 1:
                delay = min(base_delay * (2 ** attempt), max_delay)
                jitter = random.uniform(0, delay * 0.1)
                print(f"[SKILL] 请求失败，{delay + jitter:.2f}s 后重试（第 {attempt + 1}/{max_retries} 次）")
                time.sleep(delay + jitter)
        
        raise RuntimeError(f"请求在 {max_retries} 次重试后失败，请检查网络连接。")
    
    def get_kline(self, symbol: str, interval: str = "1d",
                  limit: int = 100, adjusted: bool = True) -> dict:
        """
        获取历史K线数据（对应 SKILL 函数 get_kline）
        
        参数：
            symbol: 品种代码，如 AAPL.US、0700.HK、BTC.USDT
            interval: K线周期，支持 1m/5m/15m/30m/1h/4h/1d/1w
            limit: 返回条数，最大 1000
            adjusted: 是否前复权，趋势分析建议 True
        """
        return self._request_with_retry(
            method="GET",
            endpoint="/market/kline",
            params={
                "symbol": symbol,
                "interval": interval,
                "limit": limit,
                "adjusted": str(adjusted).lower()  # API 要求字符串格式
            }
        )
    
    def get_available_symbols(self, market: Optional[str] = None) -> list:
        """
        查询可用品种列表
        用于 AI 在用户输入不明确时提供备选
        """
        params = {}
        if market:
            params["market"] = market
        
        data = self._request_with_retry(
            method="GET",
            endpoint="/symbols/available",
            params=params
        )
        return data.get("symbols", [])


# === AI 助手集成示例 ===

def ai_trading_assistant(user_query: str, skill_client: TickDBSKILL):
    """
    AI 助手通过 SKILL 协议处理用户查询的简化示例
    实际实现中，LLM 的调用和 Function Calling 由 SDK 处理
    """
    
    # 步骤1：加载 skill.md（SKILL SDK 初始化时已完成）
    # 此处模拟 AI 的函数选择过程
    
    # 模拟 AI 的函数选择逻辑
    keywords = {
        "走势": "get_kline",
        "K线": "get_kline",
        "历史价格": "get_kline",
        "可用": "get_available_symbols"
    }
    
    selected_func = None
    for keyword, func in keywords.items():
        if keyword in user_query:
            selected_func = func
            break
    
    if not selected_func:
        return "抱歉，未识别到可用的行情查询功能。请尝试 '查看XX走势' 等表述。"
    
    # 步骤2：参数提取与校验（模拟 AI 的参数推导）
    # 实际由 LLM 根据 skill.md 中的 description 和 examples 自动推导
    
    if selected_func == "get_kline":
        # 模拟参数提取
        params = {
            "symbol": extract_symbol(user_query),
            "interval": extract_interval(user_query) or "1d",
            "limit": extract_limit(user_query) or 30,
            "adjusted": True  # 趋势分析默认
        }
        
        try:
            data = skill_client.get_kline(**params)
            
            # 格式化输出
            formatted = format_kline_output(data, params["symbol"])
            return formatted
        except ValueError as e:
            return f"配置错误：{str(e)}"
        except KeyError as e:
            return f"品种错误：{str(e)}"
        except Exception as e:
            return f"查询失败：{str(e)}"
    
    return "查询完成"


def extract_symbol(query: str) -> str:
    """从查询中提取标的代码（简化示例）"""
    # 实际由 LLM + NER 模型处理
    mapping = {
        "英伟达": "NVDA.US", "NVIDIA": "NVDA.US",
        "特斯拉": "TSLA.US", "AMD": "AMD.US",
        "苹果": "AAPL.US", "腾讯": "0700.HK",
        "比特币": "BTC.USDT"
    }
    for name, code in mapping.items():
        if name in query:
            return code
    return "UNKNOWN"


# === 使用示例 ===

if __name__ == "__main__":
    # 初始化 SKILL 客户端
    skill = TickDBSKILL()
    
    # 查询示例
    queries = [
        "帮我看看英伟达最近一个月日线走势",
        "AMD 最近一周的 K 线",
        "比特币每4小时的数据，我要分析趋势"
    ]
    
    for q in queries:
        print(f"\n用户：{q}")
        result = ai_trading_assistant(q, skill)
        print(f"AI：{result}")

这段代码展示的是 SKILL 协议在 AI 助手侧的集成逻辑。在实际产品中，ai_trading_assistant 函数的逻辑由大语言模型根据 skill.md 自动生成，开发者只需要实现 TickDBSKILL 这个 HTTP 客户端，并将其注册为 AI 的工具集。

七、SKILL 协议的价值：从工具到生态

SKILL 协议的意义不限于让 AI 学会查行情。

从架构上看，SKILL 将 TickDB 从一个"被动的数据提供方"转变为一个"AI 可理解的能力集"。当市场上越来越多的 AI 助手集成了 SKILL 协议，TickDB 的数据能力可以通过 AI 的自然语言交互触达终端用户，而无需开发专门的应用层。

从开发者体验上看，SKILL 协议将 API 文档、SDK 文档和 AI 集成指南三合一。开发者不需要同时维护三套文档，只需要维护一份 skill.md，AI 和人类开发者都能从中获取所需信息。

从产品演进上看，SKILL 协议支持版本控制（meta.protocol_version）。当 TickDB 增加新接口时，只需更新 skill.md，所有集成了 SKILL 的 AI 助手无需重新开发即可感知新能力。

协议的开放性是最后一层价值。SKILL 的文件格式（YAML/JSON）和接口规范不依赖特定 AI 平台，任何实现了 SKILL SDK 的 LLM 都可以接入。这为 TickDB 打开了一个与模型无关的生态系统——不论用户的 AI 助手是 GPT、Claude 还是 Gemini，只要支持 SKILL 协议，就能无缝使用 TickDB 的行情数据。

下一步行动

如果你是 AI 工具开发者，了解 SKILL 协议后，可以查看 TickDB 的 SKILL SDK 文档（文字描述 URL，不提供可点击链接），将 TickDB 的行情能力集成到你的产品中。

如果你习惯用 AI 辅助开发，在 AI 助手中搜索安装 tickdb-market-data SKILL，在对话中直接说"帮我看看英伟达的走势"即可触发 Function Calling。

如果你需要完整的 API 技术文档，访问 tickdb.ai 的开发者文档页面，查看全部接口的 REST 规范和 WebSocket 订阅协议。

风险提示：本文不构成任何投资建议。SKILL 协议是技术协议，与投资决策无关。市场有风险，投资需谨慎。

当 AI 学会查行情：TickDB SKILL 协议的技术解剖

一、为什么需要 SKILL 协议

二、skill.md：AI 的行情查询说明书

2.1 文件定位与设计原则

2.2 文件结构总览

2.3 Meta 元信息区块

2.4 Auth 鉴权区块

2.5 Functions 函数定义区块

三、Function Calling 的定义机制

3.1 从自然语言到结构化调用的映射流程

3.2 参数推导的上下文推理

3.3 批量查询的场景支持

四、多轮对话的上下文管理

4.1 对话上下文的生命周期

4.2 上下文状态的 SKILL 标记

4.3 多轮场景示例

五、SKILL 协议与普通 Function Calling 的对比

六、生产级集成示例

七、SKILL 协议的价值：从工具到生态

下一步行动

二、`skill.md`：AI 的行情查询说明书