gamma-cost-tuning
Optimize Gamma usage costs and manage API spending. Use when reducing API costs, implementing usage quotas, or planning for scale with budget constraints. Trigger with phrases like "gamma cost", "gamma billing", "gamma budget", "gamma expensive", "gamma pricing".
- License 许可
- MIT
- 最近更新
- 2026-11-15
- Stars
- ★ 2.0k
- Forks
- 233
01 前言 Front Matter
- name
- gamma-cost-tuning
- author
- Jeremy Longshore <jeremy@intentsolutions.io>
- license
- MIT
- version
- 1.0.0
- description
- Optimize Gamma usage costs and manage API spending. Use when reducing API costs, implementing usage quotas, or planning for scale with budget constraints. Trigger with phrases like "gamma cost", "gamma billing", "gamma budget", "gamma expensive", "gamma pricing".
- allowed-tools
- Read, Write, Edit
03 SKILL.md 正文
Gamma Cost Tuning
Overview
Optimize Gamma API usage to minimize costs while maintaining functionality.
Prerequisites
- Active Gamma subscription
- Access to usage dashboard
- Understanding of pricing tiers
Gamma Pricing Model
| Resource | Free | Pro | Team | Enterprise |
|---|---|---|---|---|
| Presentations/mo | 10 | 100 | 500 | Custom |
| AI generations | 5 | 50 | 200 | Unlimited |
| Exports/mo | 10 | 100 | 500 | Unlimited |
| API calls/min | 10 | 60 | 200 | Custom |
| Storage | 1GB | 10GB | 100GB | Custom |
Instructions
Step 1: Usage Monitoring
// Track usage per operation
interface UsageTracker {
presentations: number;
generations: number;
exports: number;
apiCalls: number;
}
const dailyUsage: UsageTracker = {
presentations: 0,
generations: 0,
exports: 0,
apiCalls: 0,
};
function trackUsage(operation: keyof UsageTracker) {
dailyUsage[operation]++;
// Check if approaching limits
const limits = { presentations: 100, generations: 50, exports: 100, apiCalls: 60 };
const percentage = (dailyUsage[operation] / limits[operation]) * 100;
if (percentage >= 80) {
console.warn(`Warning: ${operation} usage at ${percentage}%`);
alertOps(`Gamma ${operation} usage high: ${percentage}%`);
}
}
// Wrap API calls
async function createPresentation(opts: object) {
trackUsage('apiCalls');
trackUsage('presentations');
if (opts.generateAI) trackUsage('generations');
return gamma.presentations.create(opts);
}
Step 2: Implement Usage Quotas
interface UserQuota {
userId: string;
presentationsRemaining: number;
generationsRemaining: number;
exportsRemaining: number;
resetsAt: Date;
}
async function checkQuota(userId: string, operation: string): Promise<boolean> {
const quota = await getQuota(userId);
const quotaField = `${operation}Remaining` as keyof UserQuota;
if (typeof quota[quotaField] === 'number' && quota[quotaField] <= 0) {
throw new QuotaExceededError(`${operation} quota exceeded`);
}
return true;
}
async function consumeQuota(userId: string, operation: string) {
await db.quotas.update({
where: { userId },
data: { [`${operation}Remaining`]: { decrement: 1 } },
});
}
// Usage in API route
app.post('/api/presentations', async (req, res) => {
await checkQuota(req.userId, 'presentations');
const result = await gamma.presentations.create(req.body);
await consumeQuota(req.userId, 'presentations');
res.json(result);
});
Step 3: Optimize AI Generation Usage
// Expensive: Full AI generation for each request
const expensive = await gamma.presentations.create({
prompt: 'Create 20 slides about AI',
generateAI: true,
slideCount: 20, // Uses lots of AI credits
});
// Cost-effective: Template + targeted AI
const costEffective = await gamma.presentations.create({
template: 'business-pitch', // Pre-made structure
title: 'Our AI Solution',
slides: [
{ title: 'Introduction', content: predefinedContent },
{ title: 'Problem', generateAI: true }, // AI only where needed
{ title: 'Solution', generateAI: true },
{ title: 'Team', content: teamData }, // No AI needed
{ title: 'Contact', content: contactInfo },
],
});
Step 4: Caching to Reduce API Calls
import Redis from 'ioredis';
const redis = new Redis(process.env.REDIS_URL);
const CACHE_TTL = 3600; // 1 hour
async function getCachedOrFetch<T>(
key: string,
fetchFn: () => Promise<T>
): Promise<T> {
// Check cache
const cached = await redis.get(key);
if (cached) {
return JSON.parse(cached);
}
// Fetch and cache
const data = await fetchFn();
await redis.setex(key, CACHE_TTL, JSON.stringify(data));
return data;
}
// Usage - reduces repeated API calls
const presentation = await getCachedOrFetch(
`presentation:${id}`,
() => gamma.presentations.get(id)
);
Step 5: Batch Operations
// Expensive: Individual operations
for (const item of items) {
await gamma.presentations.create(item); // N API calls
}
// Cost-effective: Batch operation
await gamma.presentations.createBatch(items); // 1 API call
// Or queue for off-peak processing
await queue.addBulk(items.map(item => ({
name: 'create-presentation',
data: item,
opts: { delay: calculateOffPeakDelay() },
})));
Step 6: Cost Alerts and Budgets
// Set up budget alerts
const budget = {
monthly: 100, // $100/month
current: 0,
alertThresholds: [50, 75, 90, 100],
};
async function recordCost(operation: string, cost: number) {
budget.current += cost;
for (const threshold of budget.alertThresholds) {
const percentage = (budget.current / budget.monthly) * 100;
if (percentage >= threshold) {
await sendBudgetAlert(threshold, budget.current);
}
}
if (budget.current >= budget.monthly) {
await disableNonCriticalFeatures();
}
}
Cost Reduction Strategies
| Strategy | Savings | Implementation |
|---|---|---|
| Caching | 30-50% | Redis/in-memory cache |
| Batching | 20-40% | Batch API calls |
| Templates | 40-60% | Reduce AI usage |
| Off-peak | 10-20% | Queue for low-cost periods |
| Quotas | Variable | Per-user limits |
Resources
Next Steps
Proceed to gamma-reference-architecture for architecture patterns.
04 同仓库更多 Skills
theme-factory
Toolkit for styling artifacts with a theme. These artifacts can be slides, docs, reportings, HTML landing pages, etc. There are 10 pre-set themes with colors/fonts that you can apply to any artifact that has been creating, or can generate a new theme on-the-fly.
web-artifacts-builder
Suite of tools for creating elaborate, multi-component claude.ai HTML artifacts using modern frontend web technologies (React, Tailwind CSS, shadcn/ui). Use for complex artifacts requiring state management, routing, or shadcn/ui components - not for simple single-file HTML/JSX artifacts.
webapp-testing
Toolkit for interacting with and testing local web applications using Playwright. Supports verifying frontend functionality, debugging UI behavior, capturing browser screenshots, and viewing browser logs.
neuropixels-analysis
Neuropixels neural recording analysis. Load SpikeGLX/OpenEphys data, preprocess, motion correction, Kilosort4 spike sorting, quality metrics, Allen/IBL curation, AI-assisted visual analysis, for Neuropixels 1.0/2.0 extracellular electrophysiology. Use when working with neural recordings, spike sorting, extracellular electrophysiology, or when the user mentions Neuropixels, SpikeGLX, Open Ephys, Kilosort, quality metrics, or unit curation.
skill-creator
Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Claude's capabilities with specialized knowledge, workflows, or tool integrations.
notebooklm
Use this skill to query your Google NotebookLM notebooks directly from Claude Code for source-grounded, citation-backed answers from Gemini. Browser automation, library management, persistent auth. Drastically reduced hallucinations through document-only responses.