golang-samber-hot

Configure samber/hot in-memory caching with eviction algorithms and Prometheus metrics.

1|Updated Apr 4, 2026
One-click install
npx skills add https://github.com/Jylhis/claude-marketplace --skill golang-samber-hot-jylhis
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: golang-samber-hot
Source: https://github.com/Jylhis/claude-marketplace/tree/main/plugins/golang-dev/skills/golang-samber-hot
Command: npx skills add https://github.com/Jylhis/claude-marketplace --skill golang-samber-hot-jylhis

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill provides a production‑ready in‑memory caching solution for Go services that need to reduce latency and backend pressure when repeatedly loading medium‑to‑low cardinality resources at high frequency.

Core Features & Use Cases

  • Multiple eviction algorithms including LRU, LFU, TinyLFU, W‑TinyLFU, ARC, S3FIFO, TwoQueue, SIEVE and FIFO.
  • TTL, loader chains, sharding, missing‑key caching and Prometheus metrics for observability.
  • Use case: Accelerate API responses by caching user profiles, session data, or configuration objects while automatically handling cache miss deduplication.

Quick Start

Ask the assistant to build a hot cache with 10,000 entries, a 5‑minute TTL, and the W‑TinyLFU eviction algorithm.

Frequently Asked Questions about golang-samber-hot

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement in-memory caching in a Go service to reduce backend load?▼

In-memory caching in Go reduces backend load by storing frequently accessed, low-cardinality resources. This Skill uses the samber/hot library to cache items, automatically deduplicating cache misses and managing TTLs to lower latency.

What eviction algorithms can I use for a Go cache beyond standard LRU?▼

Beyond standard LRU, Go caching eviction algorithms can include LFU, TinyLFU, W-TinyLFU, ARC, S3FIFO, TwoQueue, SIEVE, and FIFO. This Skill supports selecting among these algorithms to match specific access patterns.

Does the samber/hot library support Prometheus metrics for cache observability?▼

Yes, Prometheus metrics integration is supported for cache observability. This Skill provides fast in-memory caching with built-in Prometheus metrics, allowing you to monitor hit rates, miss rates, and overall cache performance effectively.

How do I prevent cache stampedes when loading missing keys in Go?▼

To prevent cache stampedes when loading missing keys in Go, this Skill provides loader deduplication. It ensures that concurrent requests for the same missing key result in a single backend fetch, protecting the database from sudden load spikes.

Can I cache missing keys to avoid repeatedly querying the database for non-existent data?▼

Yes, you can cache missing keys to avoid repeatedly querying the database for non-existent data. This Skill supports missing-key caching, ensuring that queries for absent resources are remembered without hitting the backend repeatedly.

What is the best way to cache user profiles and session data for a high-frequency Go API?▼

The best way to cache user profiles and session data for a high-frequency Go API is using an in-memory cache with W-TinyLFU eviction. This Skill handles high-frequency fetches of medium-to-low cardinality resources, accelerating API responses.