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.