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. ドキュメントクラスタリング
9. エラー処理
10. ベストプラクティス

---

1. クイックスタート

インストール

Google Generative AI SDK をインストールします。

npm install @google/genai@^1.27.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 Representation Learning を使用して出力の次元数を柔軟に設定できます。

次元数	ユースケース	ストレージ	パフォーマンス
768	ほとんどのユースケースで推奨	低	高速
1536	精度と効率のバランス	中	中
3072	最大精度（デフォルト）	高	低速
128-3071	カスタム（範囲内の任意の値）	可変	可変

デフォルト：3072 次元 推奨：最適なパフォーマンスを得るには 768、1536、または 3072 を使用してください。

コンテキストウィンドウ

• 入力制限：テキストあたり 2,048 トークン
• 入力タイプ：テキストのみ（画像、音声、動画には対応していません）

レート制限

ティア	RPM	TPM	RPD	要件
無料	100	30,000	1,000	請求先アカウント不要
ティア 1	3,000	1,000,000	-	請求先アカウントのリンクが必要
ティア 2	5,000	5,000,000	-	250 ドル以上の利用、30 日間の待機
ティア 3	10,000	10,000,000	-	1,000 ドル以上の利用、30 日間の待機

RPM = 1 分あたりのリクエスト数 TPM = 1 分あたりのトークン数 RPD = 1 日あたりのリクエスト数

出力形式

{
  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

---

4. バッチ埋め込み

1 回のリクエストで複数のテキストを処理（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[]}

レート制限に合わせたチャンク化

大規模なデータセットを処理する場合は、レート制限内に収まるようリクエストをチャンクに分割します。

async function batchEmbedWithRateLimit(
  texts: string[],
  batchSize: number = 100, // Free tier: 100 RPM
  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, 100);

パフォーマンスの最適化

ヒント：

1. 複数のテキストを埋め込む場合はバッチ API を使用します（複数回のリクエストではなく、1 回のリクエストで処理できます）。
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（検索拡張生成）は、ベクトル検索と LLM による生成を組み合わせ、カスタムナレッジベースを使って質問に回答する AI システムを構築します。

RAG ワークフロー全体

1. Document Ingestion
   ├── Chunk documents into smaller pieces
   ├── Generate embeddings (RETRIEVAL_DOCUMENT)
   └── Store in Vectorize

2. Query Processing
   ├── User submits query
   ├── Generate query embedding (RETRIEVAL_QUERY)
   └── Search Vectorize for similar documents

3. Response Generation
   ├── Retrieve top-k similar documents
   ├── Pass documents as context to LLM
   └── Stream response to user

ドキュメント取り込みパイプライン

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

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

// 1. Chunk document into smaller pieces
function chunkDocument(text: string, chunkSize: number = 500): string[] {
  const words = text.split(' ');
  const chunks: string[] = [];

  for (let i = 0; i < words.length; i += chunkSize) {
    chunks.push(words.slice(i, i + chunkSize).join(' '));
  }

  return chunks;
}

// 2. 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);
}

// 3. 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);
}

// Complete pipeline
async function ingestDocument(env: Env, documentText: string) {
  const chunks = chunkDocument(documentText, 500);
  const embeddings = await embedChunks(chunks);
  await storeInVectorize(env, chunks, embeddings);

  console.log(`Ingested ${chunks.length} chunks`);
}

クエリの流れ（検索＋生成）

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. セマンティック検索

セマンティック検索では、キーワードの一致だけでなく、意味に基づいてコンテンツを検索します。

コサイン類似度

コサイン類似度は、2 つの埋め込みの類似度を測定します（範囲：-1～1、1 は同一を示します）。

function cosineSimilarity(a: number[], b: number[]): number {
  if (a.length !== b.length) {
    throw new Error('Vectors must have same length');
  }

  let dotProduct = 0;
  let magnitudeA = 0;
  let magnitudeB = 0;

  for (let i = 0; i < a.length; i++) {
    dotProduct += a[i] * b[i];
    magnitudeA += a[i] * a[i];
    magnitudeB += b[i] * b[i];
  }

  if (magnitudeA === 0 || magnitudeB === 0) {
    return 0;
  }

  return dotProduct / (Math.sqrt(magnitudeA) * Math.sqrt(magnitudeB));
}

ベクトルの正規化

類似度計算を高速化するため、ベクトルを単位長に正規化します。

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

  if (magnitude === 0) {
    return vector;
  }

  return vector.map(val => val / magnitude);
}

// Normalized vectors allow dot product instead of cosine similarity
function dotProduct(a: number[], b: number[]): number {
  return a.reduce((sum, val, i) => sum + val * b[i], 0);
}

Top-K 検索

クエリに最も類似したドキュメントを検索します。

interface Document {
  id: string;
  text: string;
  embedding: number[];
}

function topKSimilar(
  queryEmbedding: number[],
  documents: Document[],
  k: number = 5
): Array<{ document: Document; similarity: number }> {
  // Calculate similarity for each document
  const similarities = documents.map(doc => ({
    document: doc,
    similarity: cosineSimilarity(queryEmbedding, doc.embedding)
  }));

  // Sort by similarity (descending) and return top K
  return similarities
    .sort((a, b) => b.similarity - a.similarity)
    .slice(0, k);
}

// Usage
const results = topKSimilar(queryEmbedding, documents, 5);

results.forEach(result => {
  console.log(`Similarity: ${result.similarity.toFixed(4)}`);
  console.log(`Text: ${result.document.text}\n`);
});

セマンティック検索の完全な例

Gemini API を使った完全な実装については、templates/semantic-search.ts を参照してください。

---

8. ドキュメントのクラスタリング

クラスタリングでは、類似したドキュメントを自動的にグループ化します。

K-means クラスタリング

interface Cluster {
  centroid: number[];
  documents: number[][];
}

function kMeansClustering(
  embeddings: number[][],
  k: number = 3,
  maxIterations: number = 100
): Cluster[] {
  // 1. Initialize centroids randomly
  const centroids: number[][] = [];
  for (let i = 0; i < k; i++) {
    centroids.push(embeddings[Math.floor(Math.random() * embeddings.length)]);
  }

  // 2. Iterate until convergence
  for (let iter = 0; iter < maxIterations; iter++) {
    // Assign each embedding to nearest centroid
    const clusters: number[][][] = Array(k).fill(null).map(() => []);

    embeddings.forEach(embedding => {
      let minDistance = Infinity;
      let closestCluster = 0;

      centroids.forEach((centroid, i) => {
        const distance = 1 - cosineSimilarity(embedding, centroid);
        if (distance < minDistance) {
          minDistance = distance;
          closestCluster = i;
        }
      });

      clusters[closestCluster].push(embedding);
    });

    // Update centroids
    let changed = false;
    clusters.forEach((cluster, i) => {
      if (cluster.length > 0) {
        const newCentroid = cluster[0].map((_, dim) =>
          cluster.reduce((sum, emb) => sum + emb[dim], 0) / cluster.length
        );

        if (cosineSimilarity(centroids[i], newCentroid) < 0.9999) {
          changed = true;
        }

        centroids[i] = newCentroid;
      }
    });

    if (!changed) break;
  }

  // Build final clusters
  const finalClusters: Cluster[] = centroids.map((centroid, i) => ({
    centroid,
    documents: embeddings.filter(emb =>
      cosineSimilarity(emb, centroid) === Math.max(
        ...centroids.map(c => cosineSimilarity(emb, c))
      )
    )
  }));

  return finalClusters;
}

実装全体と例については、templates/clustering.ts を参照してください。

用途

1. コンテンツ整理：類似した記事、製品、ドキュメントを自動的にグループ化します
2. 重複検出：ほぼ重複するコンテンツを見つけます
3. トピックモデリング：大規模なテキストコーパスからテーマを発見します
4. 顧客フィードバック分析：類似した顧客からの苦情や機能リクエストをグループ化します

---

9. エラー処理

よくあるエラー

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 を参照してください。

---

10. ベストプラクティス

必ず行うこと

✅ タスクタイプを指定する

// 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;
}

✅ 複数のテキストにはバッチ 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 - Cloudflare Workers 向けの Fetch ベースの実装
• batch-embeddings.ts - レート制限付きのバッチ処理
• rag-with-vectorize.ts - Vectorize を使った RAG の完全な実装
• semantic-search.ts - コサイン類似度と Top-K 検索
• clustering.ts - K-means クラスタリングの実装

参考資料（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 モデル）

---

成功指標

トークン削減量: 手動実装と比較して約 60％ 防止したエラー: 解決策とともに 8 件のエラーを記載 本番環境でのテスト: ✅ RAG アプリケーションで検証済み パッケージバージョン: @google/[email protected] 最終更新日: 2025-10-25

---

ライセンス

MIT ライセンス - 個人プロジェクトおよび商用プロジェクトで無料で利用できます。

---

質問や問題がありますか？

• GitHub: https://github.com/jezweb/claude-skills
• メール: [email protected]