❌  WITHOUT rtk-sf                      ✅  WITH rtk-sf
─────────────────────────────────────   ─────────────────────────────────────
Claude: "Show me OrderService.java"     Claude: "Show me OrderService.java"
  → reads OrderService.java (800 lines)  → calls get_java_skeleton()
  → reads related entity classes         → returns 80-line skeleton instantly
  → reads repository interfaces
  → reads test class for context
                                        Tokens consumed:  ~400
Tokens consumed:  ~12,000               Time:             <0.1 s
Cost (@$3/1M):    $0.036                Cost (@$3/1M):    $0.0012

                                        Savings:  97%

# Install (Salesforce + all language tracks)
pip install "rtk-sf[all] @ git+https://github.com/furuCRM-Inc/rtk-sf.git"

# Or from PyPI when available
pip install rtk-sf

# Salesforce: index your project
python3 -m rtk_sf index

# Start MCP server
python3 -m rtk_sf serve

{
  "mcpServers": {
    "rtk-sf": {
      "command": "python3",
      "args": ["-m", "rtk_sf", "serve"],
      "cwd": "/path/to/your/project"
    }
  }
}

// Java skeleton: OrderService.java
// Tokens: ~420 (vs ~2,100 raw, 80% saved)

package com.example.service;

import com.example.model.Order;
import com.example.repository.OrderRepository;
import org.springframework.stereotype.Service;

@Service
public class OrderService {
  private final OrderRepository repository;

  public OrderService(OrderRepository repository) {
    this.repository = repository;
  }

  public Order findById(String id) { /* logic hidden */ }
  public List<Order> findAll() { /* boilerplate */ }
  public Order save(Order order) { /* logic hidden */ }
  public void delete(String id) { /* logic hidden */ }
  public String getId() { /* boilerplate */ }
  public void setId(String id) { /* boilerplate */ }
}

// Kotlin skeleton: OrderService.kt
// Tokens: ~180 (vs ~900 raw, 80% saved)

package com.example

data class Order(
  val id: String,
  val customerId: String,
  val items: List<OrderItem>,
  val status: OrderStatus
)

class OrderService(private val db: MutableMap<String, Order> = mutableMapOf()) {
  fun save(order: Order) { /* logic hidden */ }
  fun findById(id: String): Order { /* logic hidden */ }
  fun findAll(): List<Order> { /* logic hidden */ }
  fun delete(id: String) { /* logic hidden */ }

  companion object {
    fun create(): OrderService { /* logic hidden */ }
  }
}

// TypeScript skeleton: PaymentService.ts
// Tokens: ~210 (vs ~1,400 raw, 85% saved)

import { Injectable } from '@nestjs/common';
import { Order } from './order.model';

@Injectable()
export class PaymentService {
  constructor(private readonly stripe: StripeClient) {}

  async charge(order: Order, currency: string): Promise<PaymentResult> { /* logic hidden */ }
  async refund(paymentId: string): Promise<void> { /* logic hidden */ }
  private validateCurrency(currency: string): boolean { /* logic hidden */ }
}

# Python skeleton: order_service.py
# Tokens: ~160 (vs ~800 raw, 80% saved)

from dataclasses import dataclass
from typing import List, Optional

@dataclass
class Order:
    id: str
    customer_id: str
    items: List[str]
    status: str

class OrderService:
    def __init__(self, db): ...
    def save(self, order: Order) -> Order: ...
    def find_by_id(self, order_id: str) -> Optional[Order]: ...
    def find_all(self) -> List[Order]: ...
    def delete(self, order_id: str) -> bool: ...

get_java_skeleton(
  file_path="/src/OrderService.java",
  focus_names=["processPayment"]
)

public class OrderService {
  public Order findById(String id) { /* logic hidden */ }

  // ← full body exposed because it's in focus_names
  public PaymentResult processPayment(Order order, String currency) {
    validateCurrency(currency);
    Payment payment = paymentGateway.charge(order.getTotal(), currency);
    order.setStatus(OrderStatus.PAID);
    return repository.save(payment);
  }

  public void delete(String id) { /* logic hidden */ }
}

rtk_sf/
├── __init__.py               # Package root (v0.8.0)
├── __main__.py               # CLI entry point
├── mcp_server.py             # MCP stdio server — all 23 tools
├── core_router.py            # Language detection router
├── indexer.py                # Salesforce DX project indexer
├── search.py                 # Keyword + semantic search
├── skeleton.py               # Apex skeleton generator
├── sf_runner.py              # Salesforce CLI wrapper
├── data_tools.py             # CSV/JSON/YAML reader
├── nlp_compactor.py          # Prompt NLP compressor
├── java/
│   ├── java_skeletonizer.py  # Java structural skeleton (getter/setter detection)
│   └── build_masker.py       # Maven + Gradle output compactor
├── kotlin/
│   ├── kt_skeletonizer.py    # Kotlin skeleton (expression-body, companion objects)
│   └── gradle_masker.py      # Gradle output compactor
├── typescript/
│   ├── ts_skeletonizer.py    # TypeScript/JS skeleton (arrow fns, decorators)
│   └── jest_masker.py        # Jest/Vitest output compactor
├── python/
│   ├── ast_skeletonizer.py   # Python AST skeleton (dataclasses, type hints)
│   └── pytest_masker.py      # pytest output compactor
└── hooks/
    ├── compact_prompt.py     # Pre-submit hook: NLP compress prompts
    └── ocr_intercept.py      # Pre-submit hook: OCR image → text

# Salesforce only (minimal)
pip install rtk-sf

# Add vector search
pip install "rtk-sf[vector]"

# Add OCR (PaddleOCR)
pip install "rtk-sf[ocr]"

# Add OCR fallback (EasyOCR)
pip install "rtk-sf[ocr-fallback]"

# Everything
pip install "rtk-sf[all]"

# Index your project (run from the Salesforce project root)
python3 -m rtk_sf index

# Re-index after code changes
python3 -m rtk_sf index

# Dry-run: see what would be indexed
python3 -m rtk_sf dry-run

rtk_sf/<language>/
├── <lang>_skeletonizer.py   # Two-pass skeleton extractor
└── <tool>_masker.py         # Build/test output compactor