google-gemini-embeddings

Google Gemini Embeddings

Google Gemini Embeddings API 完整生产就绪指南

此技能全面介绍用于生成文本嵌入的 gemini-embedding-001 模型，包括 SDK 用法、REST API 模式、批处理、与 Cloudflare Vectorize 集成的 RAG，以及语义搜索和文档聚类等高级用例。

---

目录

1. 快速入门
2. gemini-embedding-001 模型
3. 基本嵌入
4. 批量嵌入
5. 任务类型
6. RAG 模式
7. 错误处理
8. 最佳实践

---

1. 快速入门

安装

安装 Google Generative AI SDK：

npm install @google/genai@^1.37.0

对于 TypeScript 项目：

npm install -D typescript@^5.0.0

环境设置

将 Gemini API 密钥设置为环境变量：

export GEMINI_API_KEY="your-api-key-here"

从以下位置获取 API 密钥：https://aistudio.google.com/apikey

第一个嵌入示例

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });

const response = await ai.models.embedContent({
  model: 'gemini-embedding-001',
  content: 'What is the meaning of life?',
  config: {
    taskType: 'RETRIEVAL_QUERY',
    outputDimensionality: 768
  }
});

console.log(response.embedding.values); // [0.012, -0.034, ...]
console.log(response.embedding.values.length); // 768

结果：一个 768 维嵌入向量，表示文本的语义含义。

---

2. gemini-embedding-001 模型

模型规格

当前模型：gemini-embedding-001（稳定，已做好生产使用准备）

• 状态：稳定
• 实验性模型：gemini-embedding-exp-03-07（已于 2025 年 10 月弃用，请勿使用）

维度

该模型使用 Matryoshka 表示学习，支持灵活设置输出维度：

维度	用例	存储	性能
768	大多数用例的推荐选择	低	快
1536	准确性与效率之间的平衡	中	中
3072	最高准确性（默认值）	高	较慢
128-3071	自定义（范围内的任意值）	可变	可变

默认值：3072 维 推荐值：768、1536 或 3072，以获得最佳性能

上下文窗口

• 输入限制：每段文本 2,048 个 token
• 输入类型：仅文本（不支持图像、音频或视频）

速率限制

层级	RPM	TPM	RPD	要求
免费	100	30,000	1,000	无需结算账号
Tier 1	3,000	1,000,000	-	已关联结算账号
Tier 2	5,000	5,000,000	-	消费满 $250，等待 30 天
Tier 3	10,000	10,000,000	-	消费满 $1,000，等待 30 天

RPM = 每分钟请求数 TPM = 每分钟 token 数 RPD = 每日请求数

输出格式

{
  embedding: {
    values: number[] // Array of floating-point numbers
  }
}

---

3. 基本嵌入

SDK 用法（Node.js）

单个文本嵌入：

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });

const response = await ai.models.embedContent({
  model: 'gemini-embedding-001',
  content: 'The quick brown fox jumps over the lazy dog',
  config: {
    taskType: 'SEMANTIC_SIMILARITY',
    outputDimensionality: 768
  }
});

console.log(response.embedding.values);
// [0.00388, -0.00762, 0.01543, ...]

Fetch 用法（Cloudflare Workers）

适用于不支持 SDK 的 Workers/边缘环境：

export default {
  async fetch(request: Request, env: Env): Promise<Response> {
    const apiKey = env.GEMINI_API_KEY;
    const text = "What is the meaning of life?";

    const response = await fetch(
      'https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:embedContent',
      {
        method: 'POST',
        headers: {
          'x-goog-api-key': apiKey,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({
          content: {
            parts: [{ text }]
          },
          taskType: 'RETRIEVAL_QUERY',
          outputDimensionality: 768
        })
      }
    );

    const data = await response.json();

    // Response format:
    // {
    //   embedding: {
    //     values: [0.012, -0.034, ...]
    //   }
    // }

    return new Response(JSON.stringify(data), {
      headers: { 'Content-Type': 'application/json' }
    });
  }
};

解析响应

interface EmbeddingResponse {
  embedding: {
    values: number[];
  };
}

const response: EmbeddingResponse = await ai.models.embedContent({
  model: 'gemini-embedding-001',
  content: 'Sample text',
  config: { taskType: 'SEMANTIC_SIMILARITY' }
});

const embedding: number[] = response.embedding.values;
const dimensions: number = embedding.length; // 3072 by default

归一化要求

⚠️ 重要：使用非 3072 维度时，计算相似度前必须对嵌入进行归一化。只有 3072 维嵌入由 API 预先归一化。

原因：未归一化的嵌入具有不同的模长，会扭曲余弦相似度计算，导致搜索结果错误。

归一化辅助函数：

/**
 * Normalize embedding vector for accurate similarity calculations.
 * REQUIRED for dimensions other than 3072.
 *
 * @param vector - Embedding values from API response
 * @returns Normalized vector (unit length)
 */
function normalize(vector: number[]): number[] {
  const magnitude = Math.sqrt(
    vector.reduce((sum, val) => sum + val * val, 0)
  );
  return vector.map(val => val / magnitude);
}

// Usage with 768 or 1536 dimensions
const response = await ai.models.embedContent({
  model: 'gemini-embedding-001',
  content: text,
  config: {
    taskType: 'RETRIEVAL_QUERY',
    outputDimensionality: 768  // NOT 3072
  }
});

// ❌ WRONG - Use raw values directly
const embedding = response.embedding.values;
await vectorize.insert([{ id, values: embedding }]);

// ✅ CORRECT - Normalize first
const normalized = normalize(response.embedding.values);
await vectorize.insert([{ id, values: normalized }]);

来源：官方嵌入文档

---

4. 批量嵌入

在一个请求中处理多段文本（SDK）

同时为多段文本生成嵌入：

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });

const texts = [
  "What is the meaning of life?",
  "How does photosynthesis work?",
  "Tell me about the history of the internet."
];

const response = await ai.models.embedContent({
  model: 'gemini-embedding-001',
  contents: texts, // Array of strings
  config: {
    taskType: 'RETRIEVAL_DOCUMENT',
    outputDimensionality: 768
  }
});

// Process each embedding
response.embeddings.forEach((embedding, index) => {
  console.log(`Text ${index}: ${texts[index]}`);
  console.log(`Embedding: ${embedding.values.slice(0, 5)}...`);
  console.log(`Dimensions: ${embedding.values.length}`);
});

批量 REST API（fetch）

使用 batchEmbedContents 端点：

const response = await fetch(
  'https://generativelanguage.googleapis.com/v1beta/models/gemini-embedding-001:batchEmbedContents',
  {
    method: 'POST',
    headers: {
      'x-goog-api-key': apiKey,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      requests: texts.map(text => ({
        model: 'models/gemini-embedding-001',
        content: {
          parts: [{ text }]
        },
        taskType: 'RETRIEVAL_DOCUMENT'
      }))
    })
  }
);

const data = await response.json();
// data.embeddings: Array of {values: number[]}

Batch API 已知问题

⚠️ 排序 Bug（2025 年 12 月）：Batch API 在批次较大（>500 条文本）时可能无法保留顺序。

• 症状：条目 328 出现在位置 628（静默数据损坏）
• 影响：无法可靠地将结果与输入文本对应起来
• 解决方法：处理较小的批次（<100 条文本），或添加唯一 ID 以验证顺序
• 状态：Google 已确认，并创建了内部 Bug（P0 优先级）
• 来源：GitHub Issue #1207

⚠️ 内存限制（2025 年 12 月）：大型批次（>10k 个嵌入向量）可能导致 ERR_STRING_TOO_LONG 崩溃。

• 错误：Cannot create a string longer than 0x1fffffe8 characters
• 原因：API 响应包含过多空白字符（约 536MB 限制）
• 解决方法：将每批次限制为 <5,000 条文本
• 来源：GitHub Issue #1205

⚠️ 速率限制异常（2026 年 1 月）：即使未超出配额，Batch API 也可能返回 429 RESOURCE_EXHAUSTED。

• 状态：Google 团队正在调查
• 解决方法：实现指数退避和重试逻辑
• 来源：GitHub Issue #1264

速率限制下的分块处理

处理大型数据集时，请将请求分块，以遵守速率限制：

async function batchEmbedWithRateLimit(
  texts: string[],
  batchSize: number = 50, // REDUCED from 100 due to ordering bug
  delayMs: number = 60000 // 1 minute delay between batches
): Promise<number[][]> {
  const allEmbeddings: number[][] = [];

  for (let i = 0; i < texts.length; i += batchSize) {
    const batch = texts.slice(i, i + batchSize);

    console.log(`Processing batch ${i / batchSize + 1} (${batch.length} texts)`);

    const response = await ai.models.embedContent({
      model: 'gemini-embedding-001',
      contents: batch,
      config: {
        taskType: 'RETRIEVAL_DOCUMENT',
        outputDimensionality: 768
      }
    });

    allEmbeddings.push(...response.embeddings.map(e => e.values));

    // Wait before next batch (except last batch)
    if (i + batchSize < texts.length) {
      await new Promise(resolve => setTimeout(resolve, delayMs));
    }
  }

  return allEmbeddings;
}

// Usage
const embeddings = await batchEmbedWithRateLimit(documents, 50);

性能优化

提示：

1. 嵌入多条文本时使用批处理 API（单次请求，而非多次请求）
2. 选择较低的维度（768），以加快处理速度并减少存储空间
3. 针对速率限制错误实现指数退避
4. 缓存嵌入向量，避免重复调用 API

---

5. 任务类型

taskType 参数可针对特定用例优化嵌入效果。为获得最佳结果，请始终指定任务类型。

可用任务类型（共 8 种）

任务类型	用例	示例
RETRIEVAL_QUERY	用户搜索查询	“如何修理漏气的轮胎？”
RETRIEVAL_DOCUMENT	要编入索引或供搜索的文档	产品说明、文章
SEMANTIC_SIMILARITY	比较文本相似度	重复项检测、聚类
CLASSIFICATION	对文本进行分类	垃圾信息检测、情感分析
CLUSTERING	将相似文本分组	主题建模、内容整理
CODE_RETRIEVAL_QUERY	代码搜索查询	“用于排序数组的函数”
QUESTION_ANSWERING	寻求答案的问题	FAQ 匹配
FACT_VERIFICATION	根据证据验证说法	事实核查系统

如何选择

RAG 系统（检索增强生成）：

// When embedding user queries
const queryEmbedding = await ai.models.embedContent({
  model: 'gemini-embedding-001',
  content: userQuery,
  config: { taskType: 'RETRIEVAL_QUERY' } // ← Use RETRIEVAL_QUERY
});

// When embedding documents for indexing
const docEmbedding = await ai.models.embedContent({
  model: 'gemini-embedding-001',
  content: documentText,
  config: { taskType: 'RETRIEVAL_DOCUMENT' } // ← Use RETRIEVAL_DOCUMENT
});

语义搜索：

const embedding = await ai.models.embedContent({
  model: 'gemini-embedding-001',
  content: text,
  config: { taskType: 'SEMANTIC_SIMILARITY' }
});

文档聚类：

const embedding = await ai.models.embedContent({
  model: 'gemini-embedding-001',
  content: text,
  config: { taskType: 'CLUSTERING' }
});

对质量的影响

使用正确的任务类型可显著提升检索质量：

// ❌ BAD: No task type specified
const embedding1 = await ai.models.embedContent({
  model: 'gemini-embedding-001',
  content: userQuery
});

// ✅ GOOD: Task type specified
const embedding2 = await ai.models.embedContent({
  model: 'gemini-embedding-001',
  content: userQuery,
  config: { taskType: 'RETRIEVAL_QUERY' }
});

结果：使用合适的任务类型可将搜索相关性提升 10-30%。

---

6. RAG 模式

RAG（检索增强生成）将向量搜索与大模型生成相结合，构建使用自定义知识库回答问题的 AI 系统。

文档摄取管道

import { GoogleGenAI } from "@google/genai";

const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });

// Generate embeddings for chunks
async function embedChunks(chunks: string[]): Promise<number[][]> {
  const response = await ai.models.embedContent({
    model: 'gemini-embedding-001',
    contents: chunks,
    config: {
      taskType: 'RETRIEVAL_DOCUMENT', // ← Documents for indexing
      outputDimensionality: 768 // ← Match Vectorize index dimensions
    }
  });

  return response.embeddings.map(e => e.values);
}

// Store in Cloudflare Vectorize
async function storeInVectorize(
  env: Env,
  chunks: string[],
  embeddings: number[][]
) {
  const vectors = chunks.map((chunk, i) => ({
    id: `doc-${Date.now()}-${i}`,
    values: embeddings[i],
    metadata: { text: chunk }
  }));

  await env.VECTORIZE.insert(vectors);
}

查询流程（检索 + 生成）

async function ragQuery(env: Env, userQuery: string): Promise<string> {
  // 1. Embed user query
  const queryResponse = await ai.models.embedContent({
    model: 'gemini-embedding-001',
    content: userQuery,
    config: {
      taskType: 'RETRIEVAL_QUERY', // ← Query, not document
      outputDimensionality: 768
    }
  });

  const queryEmbedding = queryResponse.embedding.values;

  // 2. Search Vectorize for similar documents
  const results = await env.VECTORIZE.query(queryEmbedding, {
    topK: 5,
    returnMetadata: true
  });

  // 3. Extract context from top results
  const context = results.matches
    .map(match => match.metadata.text)
    .join('\n\n');

  // 4. Generate response with context
  const response = await ai.models.generateContent({
    model: 'gemini-2.5-flash',
    contents: `Context:\n${context}\n\nQuestion: ${userQuery}\n\nAnswer based on the context above:`
  });

  return response.text;
}

与 Cloudflare Vectorize 集成

创建 Vectorize 索引（Gemini 使用 768 个维度）：

npx wrangler vectorize create gemini-embeddings --dimensions 768 --metric cosine

在 wrangler.jsonc 中绑定：

{
  "name": "my-rag-app",
  "main": "src/index.ts",
  "compatibility_date": "2025-10-25",
  "vectorize": {
    "bindings": [
      {
        "binding": "VECTORIZE",
        "index_name": "gemini-embeddings"
      }
    ]
  }
}

完整的 RAG Worker：

完整实现请参见 templates/rag-with-vectorize.ts。

---

7. 错误处理

常见错误

1. 缺少 API 密钥或密钥无效

// ❌ Error: API key not set
const ai = new GoogleGenAI({});

// ✅ Correct
const ai = new GoogleGenAI({ apiKey: process.env.GEMINI_API_KEY });

if (!process.env.GEMINI_API_KEY) {
  throw new Error('GEMINI_API_KEY environment variable not set');
}

2. 维度不匹配

// ❌ Error: Embedding has 3072 dims, Vectorize expects 768
const embedding = await ai.models.embedContent({
  model: 'gemini-embedding-001',
  content: text
  // No outputDimensionality specified → defaults to 3072
});

await env.VECTORIZE.insert([{
  id: '1',
  values: embedding.embedding.values // 3072 dims, but index is 768!
}]);

// ✅ Correct: Match dimensions
const embedding = await ai.models.embedContent({
  model: 'gemini-embedding-001',
  content: text,
  config: { outputDimensionality: 768 } // ← Match index dimensions
});

3. 速率限制

// ❌ Error: 429 Too Many Requests
for (let i = 0; i < 1000; i++) {
  await ai.models.embedContent({ /* ... */ }); // Exceeds 100 RPM on free tier
}

// ✅ Correct: Implement rate limiting
async function embedWithRetry(text: string, maxRetries = 3) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await ai.models.embedContent({
        model: 'gemini-embedding-001',
        content: text,
        config: { taskType: 'SEMANTIC_SIMILARITY' }
      });
    } catch (error: any) {
      if (error.status === 429 && attempt < maxRetries - 1) {
        const delay = Math.pow(2, attempt) * 1000; // Exponential backoff
        await new Promise(resolve => setTimeout(resolve, delay));
        continue;
      }
      throw error;
    }
  }
}

所有 8 种已记录错误及详细解决方案，请参见 references/top-errors.md。

预防已知问题

本节记录了在生产环境使用中发现的其他问题（除上述基本错误之外）。

Issue #9：非 3072 维度需要归一化

错误：相似度分数不正确，且未抛出错误 来源：官方 Embeddings 文档 原因：只有 3072 维的嵌入向量会由 API 预先归一化。其他所有维度（128-3071）的向量大小各不相同，会扭曲余弦相似度。 预防措施：使用 3072 以外的维度时，始终对嵌入向量进行归一化。

function normalize(vector: number[]): number[] {
  const magnitude = Math.sqrt(vector.reduce((sum, val) => sum + val * val, 0));
  return vector.map(val => val / magnitude);
}

// When using 768 or 1536 dimensions
const response = await ai.models.embedContent({
  model: 'gemini-embedding-001',
  content: text,
  config: { outputDimensionality: 768 }
});

const normalized = normalize(response.embedding.values);
// Now safe for similarity calculations

Issue #10：Batch API 排序错误

错误：静默数据损坏——返回的嵌入向量顺序错误 来源：GitHub Issue #1207 原因：Batch API 在批次较大时（>500 条文本）无法保留顺序。例如：条目 328 出现在位置 628。 预防措施：处理较小的批次（<100 条文本），或添加唯一标识符以验证顺序。

// Safer approach with verification
const taggedTexts = texts.map((text, i) => `[ID:${i}] ${text}`);
const response = await ai.models.embedContent({
  model: 'gemini-embedding-001',
  contents: taggedTexts,
  config: { taskType: 'RETRIEVAL_DOCUMENT', outputDimensionality: 768 }
});

// Verify ordering by parsing IDs if needed

Issue #11：Batch API 内存限制

错误：Cannot create a string longer than 0x1fffffe8 characters 来源：GitHub Issue #1205 原因：Batch API 响应包含过多空白字符，导致大载荷（>10k 个嵌入向量）的响应大小超过 Node.js 字符串限制（约 536MB）。 预防措施：将每个请求的批次限制在 <5,000 条文本。

// Safe batch size
async function batchEmbedSafe(texts: string[]) {
  const maxBatchSize = 5000;
  if (texts.length > maxBatchSize) {
    throw new Error(`Batch too large: ${texts.length} texts (max: ${maxBatchSize})`);
  }
  // Process batch...
}

Issue #12：LangChain 忽略维度参数（社区来源）

错误：维度不匹配——指定为 768 维，实际却得到 3072 维 来源：Medium 文章 已验证：有多个社区报告 原因：将 output_dimensionality 参数传递给构造函数时，LangChain 的 GoogleGenerativeAIEmbeddings 类会静默忽略该参数（Python SDK）。 预防措施：将维度参数传递给 embed_documents() 方法，而不是构造函数。JavaScript 用户应确认新的 @google/genai SDK 没有类似行为。

# ❌ WRONG - parameter silently ignored
embeddings = GoogleGenerativeAIEmbeddings(
    model="gemini-embedding-001",
    output_dimensionality=768  # IGNORED!
)

# ✅ CORRECT - pass to method
embeddings = GoogleGenerativeAIEmbeddings(model="gemini-embedding-001")
result = embeddings.embed_documents(["text"], output_dimensionality=768)

Issue #13：单次请求使用批处理端点（社区来源）

错误：单条文本嵌入触发速率限制的速度超出预期 来源：GitHub Issue #427（Python SDK） 已验证：googleapis 组织中的官方 Issue 原因：即使处理单条文本，embed_content() 函数内部也会调用 batchEmbedContents 端点。这会消耗更多速率限制配额（批处理端点的限制不同）。 预防措施：在单次嵌入请求之间添加延迟，并针对 429 错误实现指数退避。

// Add delays to avoid rate limits
async function embedWithDelay(text: string, delayMs: number = 100) {
  const response = await ai.models.embedContent({
    model: 'gemini-embedding-001',
    content: text,
    config: { taskType: 'SEMANTIC_SIMILARITY' }
  });
  await new Promise(resolve => setTimeout(resolve, delayMs));
  return response.embedding.values;
}

---

8. 最佳实践

始终执行

✅ 指定任务类型

// Task type optimizes embeddings for your use case
const embedding = await ai.models.embedContent({
  model: 'gemini-embedding-001',
  content: text,
  config: { taskType: 'RETRIEVAL_QUERY' } // ← Always specify
});

✅ 使维度与 Vectorize 匹配

// Ensure embeddings match your Vectorize index dimensions
const embedding = await ai.models.embedContent({
  model: 'gemini-embedding-001',
  content: text,
  config: { outputDimensionality: 768 } // ← Match index
});

✅ 实现速率限制

// Use exponential backoff for 429 errors
async function embedWithBackoff(text: string) {
  // Implementation from Error Handling section
}

✅ 缓存嵌入向量

// Cache embeddings to avoid redundant API calls
const cache = new Map<string, number[]>();

async function getCachedEmbedding(text: string): Promise<number[]> {
  if (cache.has(text)) {
    return cache.get(text)!;
  }

  const response = await ai.models.embedContent({
    model: 'gemini-embedding-001',
    content: text,
    config: { taskType: 'SEMANTIC_SIMILARITY' }
  });

  const embedding = response.embedding.values;
  cache.set(text, embedding);
  return embedding;
}

✅ 对多条文本使用 Batch API

// Single batch request vs multiple individual requests
const embeddings = await ai.models.embedContent({
  model: 'gemini-embedding-001',
  contents: texts, // Array of texts
  config: { taskType: 'RETRIEVAL_DOCUMENT' }
});

绝不执行

❌ 不要跳过任务类型

// Reduces quality by 10-30%
const embedding = await ai.models.embedContent({
  model: 'gemini-embedding-001',
  content: text
  // Missing taskType!
});

❌ 不要混用不同维度

// Can't compare embeddings with different dimensions
const emb1 = await ai.models.embedContent({
  model: 'gemini-embedding-001',
  content: text1,
  config: { outputDimensionality: 768 }
});

const emb2 = await ai.models.embedContent({
  model: 'gemini-embedding-001',
  content: text2,
  config: { outputDimensionality: 1536 } // Different dimensions!
});

// ❌ Can't calculate similarity between different dimensions
const similarity = cosineSimilarity(emb1.embedding.values, emb2.embedding.values);

❌ 不要在 RAG 中使用错误的任务类型

// Reduces search quality
const queryEmbedding = await ai.models.embedContent({
  model: 'gemini-embedding-001',
  content: query,
  config: { taskType: 'RETRIEVAL_DOCUMENT' } // Wrong! Should be RETRIEVAL_QUERY
});

---

使用捆绑资源

模板（templates/）

• package.json - 包配置，包含已验证的版本
• basic-embeddings.ts - 使用 SDK 生成单条文本嵌入
• embeddings-fetch.ts - 基于 Fetch，适用于 Cloudflare Workers
• batch-embeddings.ts - 带速率限制的批处理
• rag-with-vectorize.ts - 使用 Vectorize 的完整 RAG 实现

参考资料（references/）

• model-comparison.md - 比较 Gemini、OpenAI 和 Workers AI 的嵌入模型
• vectorize-integration.md - Cloudflare Vectorize 的设置和模式
• rag-patterns.md - 完整的 RAG 实现策略
• dimension-guide.md - 选择合适的维度（768、1536 或 3072）
• top-errors.md - 8 个常见错误及详细解决方案

脚本（scripts/）

• check-versions.sh - 验证 @google/genai 软件包版本是否为最新版本

---

官方文档

• 嵌入指南：https://ai.google.dev/gemini-api/docs/embeddings
• 模型规范：https://ai.google.dev/gemini-api/docs/models/gemini#gemini-embedding-001
• 速率限制：https://ai.google.dev/gemini-api/docs/rate-limits
• SDK 参考：https://www.npmjs.com/package/@google/genai
• Context7 库 ID：/websites/ai_google_dev_gemini-api

---

相关技能

• google-gemini-api - 用于文本/图像生成的 Gemini API 主服务
• cloudflare-vectorize - 用于存储嵌入的向量数据库
• cloudflare-workers-ai - Workers AI 嵌入（BGE 模型）

---

成功指标

Token 节省：与手动实现相比约节省 60% 避免的错误：记录了 13 个错误及其解决方案（8 个基本错误 + 5 个已知问题） 生产环境测试：✅ 已在 RAG 应用中验证 软件包版本：@google/[email protected] 最近更新：2026-01-21 变更：新增规范化要求、批处理 API 警告（排序错误、内存限制、速率限制异常）以及 LangChain 兼容性说明

---

许可证

MIT 许可证 - 可免费用于个人和商业项目。

---

有问题或遇到故障？

• GitHub：https://github.com/jezweb/claude-skills
• 电子邮件：[email protected]