Cursor コスト最適化：トークン節約・キャッシュ・差分駆動で費用を半減

2025年11月30日

Cursor

AI 駆動の開発環境として注目を集める Cursor ですが、使い込むほどに気になるのが API コスト の問題です。特に大規模なコードベースでの作業や頻繁なコード生成を行う場合、月々の費用が予想以上に膨らんでしまうことがあります。

しかし、適切な最適化戦略を取り入れることで、コストを大幅に削減できるのです。本記事では、トークン使用量の削減、キャッシュの活用、差分駆動のアプローチという 3 つの核心的な技術 を用いて、Cursor の運用コストを半減させる方法を詳しく解説いたします。

実際の開発現場で即座に活用できる具体的なコード例とともに、コスト削減のベストプラクティスをお伝えしますので、ぜひ最後までご覧ください。

背景

Cursor における AI コストの仕組み

Cursor は OpenAI の GPT モデルや Claude などの大規模言語モデル（LLM）を利用してコード生成や補完を実行します。これらの LLM は トークン単位 で課金されるため、送信するプロンプトの長さと生成される応答の長さに応じてコストが発生するのです。

トークンとは、テキストを処理する際の最小単位のことで、英語では約 4 文字、日本語では約 2〜3 文字が 1 トークンに相当します。例えば、1,000 行のコードファイル全体をコンテキストとして送信すると、数千〜数万トークンを消費することになります。

従来の開発フローとコスト増加の要因

従来の Cursor 利用では、以下のような非効率なパターンが見られました。

毎回のリクエストで全ファイルの内容を送信してしまう、不要なコンテキスト情報まで含めてしまう、同じ質問を繰り返し行う、といった行動です。これらは一見些細なことに思えますが、積み重なると月間で数万円規模のコスト差を生むことになります。

下記の図は、従来の開発フローにおけるトークン消費の流れを示しています。

mermaidflowchart TD
    dev["開発者"] -->|コード生成リクエスト| cursor["Cursor"]
    cursor -->|全ファイル送信| api["LLM API"]
    api -->|大量トークン消費| billing["課金"]
    cursor -->|同じ質問を繰り返し| api
    api -->|重複コスト発生| billing
    billing -->|月間費用増大| cost["高額請求"]

図で理解できる要点：

開発者のリクエストごとに全ファイルが送信される
重複した質問でも毎回新規に課金される
結果として月間コストが急増する

課題

大規模コードベースでのトークン爆発

プロジェクトが成長するにつれ、コードベースのサイズも増大します。数百のファイル、数万行のコードを抱えるプロジェクトでは、Cursor が参照すべきコンテキストの範囲が広がり、1 回のリクエストで 数万〜数十万トークン を消費することも珍しくありません。

例えば、Next.js で構築された中規模の Web アプリケーションでは、以下のようなファイル構成が一般的です。

#	ファイル種別	ファイル数	平均トークン数	合計トークン数
1	React コンポーネント	50	800	40,000
2	API ルート	20	600	12,000
3	型定義ファイル	30	400	12,000
4	ユーティリティ関数	25	300	7,500
5	設定ファイル	10	200	2,000

このようなプロジェクトで全体をコンテキストに含めると、1 回のリクエストだけで 73,500 トークン を消費してしまいます。

コンテキストの重複送信

Cursor は会話のコンテキストを維持するため、以前の質問と回答を含めた状態で次のリクエストを送信します。しかし、この仕組みにより 同じコード情報が何度も送信される ことになり、無駄なトークン消費が発生するのです。

例えば、同じコンポーネントについて 3 回質問すると、そのコンポーネントのコードが 3 回送信され、3 倍のコストがかかることになります。

キャッシュ未活用による非効率性

多くの開発者は、Cursor のキャッシュ機能を十分に活用していません。同じファイルや同じ質問に対する応答は、本来であればキャッシュから取得できるはずなのに、毎回新規にリクエストを送信してしまうケースが多いのです。

以下の図は、キャッシュ未活用時の問題を視覚化したものです。

mermaidsequenceDiagram
    participant 開発者
    participant Cursor
    participant LLM API
    participant キャッシュ

    開発者->>Cursor: 質問A（初回）
    Cursor->>LLM API: 全コンテキスト送信
    LLM API-->>Cursor: 回答A
    Note over キャッシュ: 未保存

    開発者->>Cursor: 質問A（2回目）
    Cursor->>LLM API: 全コンテキスト再送信
    LLM API-->>Cursor: 回答A（重複）
    Note over キャッシュ: 未活用

図で理解できる要点：

同じ質問でもキャッシュが使われず、毎回 API 呼び出しが発生
トークンコストが無駄に重複している
キャッシュ機構が存在するのに活用されていない

解決策

トークン節約戦略

トークン消費を削減する最も効果的な方法は、必要最小限のコンテキストのみを送信する ことです。以下の戦略を実装することで、トークン使用量を大幅に削減できます。

コンテキスト範囲の最適化

全ファイルを送信するのではなく、現在編集中のファイルと、その依存関係にあるファイルのみをコンテキストに含めます。

typescript// context-optimizer.ts
interface FileContext {
  path: string;
  content: string;
  dependencies: string[];
}

上記は、ファイルコンテキストを管理するための型定義です。各ファイルのパス、内容、依存関係を明示的に管理することで、必要な情報だけを抽出できます。

typescript/**
 * 現在のファイルに関連する最小限のコンテキストを抽出
 * @param currentFile 現在編集中のファイルパス
 * @param allFiles プロジェクト内の全ファイル情報
 * @returns 最適化されたコンテキスト
 */
export function optimizeContext(
  currentFile: string,
  allFiles: FileContext[]
): FileContext[] {
  const relevant: FileContext[] = [];
  const visited = new Set<string>();

  // 現在のファイルを取得
  const current = allFiles.find(
    (f) => f.path === currentFile
  );
  if (!current) return [];

  // 再帰的に依存関係を収集
  function collectDependencies(file: FileContext) {
    if (visited.has(file.path)) return;
    visited.add(file.path);
    relevant.push(file);

    // 依存ファイルを収集（最大2階層まで）
    file.dependencies.forEach((depPath) => {
      const dep = allFiles.find((f) => f.path === depPath);
      if (dep && visited.size < 10) {
        // 最大10ファイルまで
        collectDependencies(dep);
      }
    });
  }

  collectDependencies(current);
  return relevant;
}

この関数は、現在のファイルから始めて、必要な依存関係のみを再帰的に収集します。最大深度を 2 階層、最大ファイル数を 10 に制限することで、コンテキストサイズを制御しています。

圧縮とサマリー化

長いコードファイルは、完全な内容ではなく サマリー（要約） を送信することで、トークン数を削減できます。

typescript// code-summarizer.ts
interface CodeSummary {
  fileName: string;
  exports: string[]; // エクスポートされる関数・クラス
  imports: string[]; // インポート元
  mainPurpose: string; // ファイルの主な目的（1-2文）
}

typescript/**
 * コードファイルからサマリーを生成
 * @param fileContent ファイルの完全な内容
 * @returns コードサマリー
 */
export function summarizeCode(
  fileContent: string
): CodeSummary {
  const lines = fileContent.split('\n');

  // エクスポートを抽出
  const exports = lines
    .filter((line) => line.includes('export'))
    .map((line) => {
      // "export function foo" -> "foo"
      const match = line.match(
        /export\s+(function|class|const)\s+(\w+)/
      );
      return match ? match[2] : '';
    })
    .filter(Boolean);

  // インポートを抽出
  const imports = lines
    .filter((line) => line.includes('import'))
    .map((line) => {
      // "import { x } from 'y'" -> "y"
      const match = line.match(/from\s+['"](.+)['"]/);
      return match ? match[1] : '';
    })
    .filter(Boolean);

  return {
    fileName: '',
    exports,
    imports,
    mainPurpose: 'ファイルの主な機能を記述',
  };
}

サマリー化により、1,000 行のファイルを 50〜100 トークン程度の要約に圧縮できます。これは 90%以上のトークン削減 に相当します。

キャッシュ戦略

キャッシュを効果的に活用することで、同じ情報を繰り返し送信する必要がなくなります。

ローカルキャッシュの実装

Cursor のリクエスト結果をローカルにキャッシュし、同じ質問には即座に回答できるようにします。

typescript// cache-manager.ts
interface CacheEntry {
  key: string;
  value: string;
  timestamp: number;
  tokenCount: number;
}

typescriptexport class CursorCache {
  private cache: Map<string, CacheEntry> = new Map();
  private readonly maxAge = 3600000; // 1時間

  /**
   * キャッシュから値を取得
   * @param key キャッシュキー
   * @returns キャッシュされた値、または null
   */
  get(key: string): string | null {
    const entry = this.cache.get(key);
    if (!entry) return null;

    // 有効期限チェック
    const age = Date.now() - entry.timestamp;
    if (age > this.maxAge) {
      this.cache.delete(key);
      return null;
    }

    return entry.value;
  }

  /**
   * キャッシュに値を保存
   * @param key キャッシュキー
   * @param value 保存する値
   * @param tokenCount トークン数
   */
  set(
    key: string,
    value: string,
    tokenCount: number
  ): void {
    this.cache.set(key, {
      key,
      value,
      timestamp: Date.now(),
      tokenCount,
    });
  }

  /**
   * 節約されたトークン数を計算
   * @returns 合計節約トークン数
   */
  getSavedTokens(): number {
    let total = 0;
    this.cache.forEach((entry) => {
      total += entry.tokenCount;
    });
    return total;
  }
}

このキャッシュマネージャーは、1 時間の有効期限付きでリクエスト結果を保存します。同じリクエストが来た場合、API を呼び出さずにキャッシュから返すことで、トークンコストをゼロに抑えられます。

セマンティックキャッシュの活用

完全一致だけでなく、意味的に類似した質問 に対してもキャッシュを活用できます。

typescript// semantic-cache.ts
import { createHash } from 'crypto';

/**
 * 質問文を正規化してハッシュ化
 * @param question 質問文
 * @returns 正規化されたハッシュキー
 */
export function normalizeQuestion(
  question: string
): string {
  // 小文字化、空白の正規化
  const normalized = question
    .toLowerCase()
    .replace(/\s+/g, ' ')
    .trim();

  // ハッシュ化
  return createHash('sha256')
    .update(normalized)
    .digest('hex');
}

typescript/**
 * 類似質問を検出
 * @param question 新しい質問
 * @param cachedQuestions キャッシュされた質問のリスト
 * @returns 類似度が高い質問、またはnull
 */
export function findSimilarQuestion(
  question: string,
  cachedQuestions: string[]
): string | null {
  const normalized = normalizeQuestion(question);

  for (const cached of cachedQuestions) {
    const cachedNormalized = normalizeQuestion(cached);

    // 簡易的な類似度チェック（実際にはより高度な手法を使用可能）
    if (normalized === cachedNormalized) {
      return cached;
    }
  }

  return null;
}

差分駆動アプローチ

ファイル全体ではなく、変更された部分のみ を送信することで、トークン使用量を劇的に削減できます。

Git Diff の活用

Git の差分情報を利用して、変更箇所のみをコンテキストに含めます。

typescript// diff-analyzer.ts
import { execSync } from 'child_process';

interface DiffInfo {
  filePath: string;
  additions: string[];
  deletions: string[];
  context: string[]; // 変更箇所の前後数行
}

typescript/**
 * Git diffから変更情報を抽出
 * @param filePath 対象ファイルパス
 * @returns 差分情報
 */
export function analyzeDiff(
  filePath: string
): DiffInfo | null {
  try {
    // Git diffを実行（前後3行のコンテキスト付き）
    const diff = execSync(`git diff -U3 ${filePath}`, {
      encoding: 'utf-8',
    });

    if (!diff) return null;

    const additions: string[] = [];
    const deletions: string[] = [];
    const context: string[] = [];

    // Diff出力を解析
    diff.split('\n').forEach((line) => {
      if (line.startsWith('+') && !line.startsWith('+++')) {
        additions.push(line.substring(1));
      } else if (
        line.startsWith('-') &&
        !line.startsWith('---')
      ) {
        deletions.push(line.substring(1));
      } else if (line.startsWith(' ')) {
        context.push(line.substring(1));
      }
    });

    return {
      filePath,
      additions,
      deletions,
      context,
    };
  } catch (error) {
    return null;
  }
}

この関数は、Git の diff コマンドを実行し、追加・削除された行と、その周辺のコンテキストを抽出します。ファイル全体（例：1,000 行）ではなく、変更部分（例：10 行）のみを送信できるため、トークンを 99%削減 できることもあります。

インクリメンタル更新

前回のリクエストからの差分のみを送信する仕組みを実装します。

typescript// incremental-updater.ts
interface FileState {
  path: string;
  content: string;
  hash: string;
  lastSent: number;
}

typescriptexport class IncrementalUpdater {
  private fileStates: Map<string, FileState> = new Map();

  /**
   * ファイルの内容をハッシュ化
   * @param content ファイル内容
   * @returns SHA-256ハッシュ
   */
  private hashContent(content: string): string {
    return createHash('sha256')
      .update(content)
      .digest('hex');
  }

  /**
   * ファイルが変更されたかチェック
   * @param path ファイルパス
   * @param content 現在の内容
   * @returns 変更されている場合はtrue
   */
  hasChanged(path: string, content: string): boolean {
    const currentHash = this.hashContent(content);
    const state = this.fileStates.get(path);

    if (!state) return true;
    return state.hash !== currentHash;
  }

  /**
   * 変更されたファイルのみを取得
   * @param files 現在のファイルリスト
   * @returns 変更されたファイルのみ
   */
  getChangedFiles(files: FileContext[]): FileContext[] {
    return files.filter((file) =>
      this.hasChanged(file.path, file.content)
    );
  }

  /**
   * ファイル状態を更新
   * @param path ファイルパス
   * @param content ファイル内容
   */
  updateState(path: string, content: string): void {
    this.fileStates.set(path, {
      path,
      content,
      hash: this.hashContent(content),
      lastSent: Date.now(),
    });
  }
}

下記の図は、差分駆動アプローチの動作フローを示しています。

mermaidflowchart TD
    start["ファイル編集"] --> check["変更検出"]
    check -->|変更あり| diff["差分抽出"]
    check -->|変更なし| skip["送信スキップ"]
    diff --> send["差分のみ送信"]
    send --> api["LLM API"]
    api --> response["応答受信"]
    response --> update["状態更新"]
    skip --> done["完了"]
    update --> done

図で理解できる要点：

ファイルの変更を検出してから処理を開始
変更がない場合は API 呼び出しをスキップ
変更がある場合のみ差分を抽出して送信

具体例

実践：Next.js プロジェクトでのコスト半減

実際の Next.js プロジェクトで、これまでの技術を統合してコストを削減する例を見ていきましょう。

プロジェクト構成

典型的な Next.js プロジェクトの構成は以下の通りです。

typescript// project-structure.ts
const projectStructure = {
  src: {
    app: ['page.tsx', 'layout.tsx'],
    components: [
      'Header.tsx',
      'Footer.tsx',
      'ProductCard.tsx',
    ],
    api: ['products/route.ts', 'users/route.ts'],
    lib: ['db.ts', 'utils.ts'],
    types: ['product.ts', 'user.ts'],
  },
  public: ['images', 'fonts'],
  config: ['next.config.js', 'tsconfig.json'],
};

統合最適化システムの実装

これまでの技術を組み合わせた統合システムを構築します。

typescript// cursor-optimizer.ts
import { CursorCache } from './cache-manager';
import { IncrementalUpdater } from './incremental-updater';
import { optimizeContext } from './context-optimizer';
import { analyzeDiff } from './diff-analyzer';

typescriptexport class CursorOptimizer {
  private cache: CursorCache;
  private updater: IncrementalUpdater;
  private tokensSaved: number = 0;

  constructor() {
    this.cache = new CursorCache();
    this.updater = new IncrementalUpdater();
  }

  /**
   * 最適化されたリクエストを準備
   * @param currentFile 現在のファイル
   * @param question 質問内容
   * @param allFiles 全ファイル情報
   * @returns 最適化されたコンテキスト
   */
  async prepareOptimizedRequest(
    currentFile: string,
    question: string,
    allFiles: FileContext[]
  ) {
    // 1. キャッシュチェック
    const cacheKey = `${currentFile}:${question}`;
    const cached = this.cache.get(cacheKey);

    if (cached) {
      console.log('✓ キャッシュヒット - API呼び出しなし');
      return { fromCache: true, data: cached };
    }

    // 2. 差分解析
    const diff = analyzeDiff(currentFile);
    const hasChanges = diff !== null;

    if (!hasChanges) {
      console.log('✓ 変更なし - 前回の結果を使用');
      return { fromCache: true, data: null };
    }

    // 3. コンテキスト最適化
    const relevantFiles = optimizeContext(
      currentFile,
      allFiles
    );

    // 4. 変更ファイルのみ抽出
    const changedFiles =
      this.updater.getChangedFiles(relevantFiles);

    return {
      fromCache: false,
      files: changedFiles,
      diff: diff,
      question: question,
    };
  }

  /**
   * トークン節約量を計算
   * @param original 元のトークン数
   * @param optimized 最適化後のトークン数
   * @returns 節約率（パーセンテージ）
   */
  calculateSavings(
    original: number,
    optimized: number
  ): number {
    const saved = original - optimized;
    const percentage = (saved / original) * 100;
    this.tokensSaved += saved;

    return percentage;
  }

  /**
   * 統計情報を取得
   * @returns 累計節約トークン数と節約率
   */
  getStats() {
    const cacheTokens = this.cache.getSavedTokens();

    return {
      totalSaved: this.tokensSaved + cacheTokens,
      cacheHits: cacheTokens,
      diffSavings: this.tokensSaved,
    };
  }
}

この統合システムは、キャッシュ、差分解析、コンテキスト最適化を組み合わせて、最大限のコスト削減を実現します。

使用例とコスト比較

実際の使用シーンでのコスト削減効果を見てみましょう。

typescript// usage-example.ts
import { CursorOptimizer } from './cursor-optimizer';

async function example() {
  const optimizer = new CursorOptimizer();

  // シナリオ: ProductCard.tsxコンポーネントの修正を依頼
  const currentFile = 'src/components/ProductCard.tsx';
  const question =
    '価格表示にカンマ区切りを追加してください';

  const allFiles: FileContext[] = [
    // プロジェクト内の全ファイル情報
    // （実際には数十〜数百ファイル）
  ];

  // 最適化リクエストの準備
  const request = await optimizer.prepareOptimizedRequest(
    currentFile,
    question,
    allFiles
  );

  if (request.fromCache) {
    console.log('キャッシュから即座に回答');
  } else {
    console.log(
      `送信ファイル数: ${request.files?.length || 0}`
    );
    console.log(
      `差分行数: ${request.diff?.additions.length || 0}`
    );
  }
}

typescript// コスト比較データ
const costComparison = {
  最適化前: {
    送信ファイル数: 50,
    平均トークン数: 800,
    総トークン数: 40000,
    月間リクエスト数: 500,
    月間総トークン数: 20000000, // 2000万トークン
    月額コスト: 30000, // 円（仮定）
  },
  最適化後: {
    送信ファイル数: 3,
    平均トークン数: 150,
    総トークン数: 450,
    月間リクエスト数: 500,
    月間総トークン数: 225000, // 22.5万トークン
    キャッシュヒット率: 0.6, // 60%
    実トークン数: 90000, // キャッシュ考慮後
    月額コスト: 1350, // 円（仮定）
  },
};

上記の比較表から、以下の改善効果が確認できます。

#	指標	最適化前	最適化後	改善率
1	1 回あたりトークン数	40,000	450	98.9%削減
2	月間総トークン数	20,000,000	90,000	99.6%削減
3	月額コスト	¥30,000	¥1,350	95.5%削減

モニタリングとダッシュボード

コスト削減効果を可視化するためのモニタリングシステムも重要です。

typescript// monitoring.ts
interface UsageMetrics {
  date: string;
  totalRequests: number;
  cacheHits: number;
  tokensSent: number;
  tokensSaved: number;
  estimatedCost: number;
}

typescriptexport class CostMonitor {
  private metrics: UsageMetrics[] = [];

  /**
   * 日次メトリクスを記録
   * @param metrics 使用量メトリクス
   */
  recordDailyMetrics(metrics: UsageMetrics): void {
    this.metrics.push(metrics);
  }

  /**
   * 週次レポートを生成
   * @returns 過去7日間の統計
   */
  generateWeeklyReport() {
    const recent = this.metrics.slice(-7);

    const totalRequests = recent.reduce(
      (sum, m) => sum + m.totalRequests,
      0
    );
    const totalCacheHits = recent.reduce(
      (sum, m) => sum + m.cacheHits,
      0
    );
    const totalTokensSaved = recent.reduce(
      (sum, m) => sum + m.tokensSaved,
      0
    );
    const totalCost = recent.reduce(
      (sum, m) => sum + m.estimatedCost,
      0
    );

    const cacheHitRate =
      (totalCacheHits / totalRequests) * 100;

    return {
      period: '過去7日間',
      requests: totalRequests,
      cacheHitRate: `${cacheHitRate.toFixed(1)}%`,
      tokensSaved: totalTokensSaved.toLocaleString(),
      totalCost: `¥${totalCost.toLocaleString()}`,
      averageDailyCost: `¥${(totalCost / 7).toFixed(0)}`,
    };
  }

  /**
   * アラート条件をチェック
   * @returns アラートメッセージ（問題がある場合）
   */
  checkAlerts(): string[] {
    const alerts: string[] = [];
    const today = this.metrics[this.metrics.length - 1];

    if (!today) return alerts;

    // キャッシュヒット率が50%未満
    const hitRate =
      (today.cacheHits / today.totalRequests) * 100;
    if (hitRate < 50) {
      alerts.push(
        `⚠️ キャッシュヒット率が低下: ${hitRate.toFixed(
          1
        )}%`
      );
    }

    // 1日のコストが想定を超過
    if (today.estimatedCost > 500) {
      alerts.push(
        `⚠️ 日次コストが高額: ¥${today.estimatedCost}`
      );
    }

    return alerts;
  }
}