Quick Start Guide

curl https://api.cachee.ai/v1/signup \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "email": "your@email.com",
    "company": "Your Company",
    "name": "Your Name"
  }'

# Response:
{
  "api_key": "sk_live_xxxxxxxxxxxxx",
  "dashboard_url": "https://dashboard.cachee.ai"
}

pip install cachee-sdk

npm install @cachee/sdk
# or
yarn add @cachee/sdk

go get github.com/cachee-ai/go-sdk

<dependency>
  <groupId>ai.cachee</groupId>
  <artifactId>cachee-sdk</artifactId>
  <version>1.0.0</version>
</dependency>

from cachee_sdk import Cachee
import os

# Initialize Cachee.ai
cachee = Cachee(
    api_key=os.getenv("CACHEE_API_KEY"),
    region="us-east-1"  # Auto-detects from AWS metadata
)

print("✅ Cachee.ai initialized!")

const { Cachee } = require('@cachee/sdk');

// Initialize Cachee.ai
const cachee = new Cachee({
  apiKey: process.env.CACHEE_API_KEY,
  region: 'us-east-1'
});

console.log('✅ Cachee.ai initialized!');

package main

import (
    "os"
    "github.com/cachee-ai/go-sdk"
)

func main() {
    // Initialize Cachee.ai
    client := cachee.NewClient(&cachee.Config{
        APIKey: os.Getenv("CACHEE_API_KEY"),
        Region: "us-east-1",
    })

    println("✅ Cachee.ai initialized!")
}

import ai.cachee.CacheeClient;

public class Main {
    public static void main(String[] args) {
        // Initialize Cachee.ai
        CacheeClient cachee = new CacheeClient.Builder()
            .apiKey(System.getenv("CACHEE_API_KEY"))
            .region("us-east-1")
            .build();

        System.out.println("✅ Cachee.ai initialized!");
    }
}

from cachee_sdk import cachee

# Example: Database query with intelligent caching
@cachee.cache(
    key="user:{user_id}",
    ttl_strategy="adaptive",     # AI adjusts TTL automatically
    prefetch_related=True         # Predicts and pre-fetches related data
)
async def get_user(user_id: int):
    """
    Cachee.ai automatically:
    - Predicts when to refresh (before expiry)
    - Adjusts TTL based on access patterns
    - Pre-fetches frequently accessed related data
    - Detects anomalies in cache behavior
    """
    result = await db.query(
        "SELECT * FROM users WHERE id = $1",
        user_id
    )
    return result

# Example: API call with fallback
@cachee.cache(
    key="external_api:{endpoint}",
    fallback_on_error=True,       # Serve stale on API failure
    stale_while_revalidate=60     # Return cached, refresh in background
)
async def call_external_api(endpoint: str):
    response = await httpx.get(f"https://api.example.com/{endpoint}")
    return response.json()

# Example: Complex aggregation with warming
@cachee.cache(
    key="analytics:{user_id}:{date}",
    warm_cache=True,              # Pre-compute during off-peak hours
    invalidate_on=["user_updated", "order_placed"]
)
async def get_analytics_dashboard(user_id: int, date: str):
    # Expensive aggregation query
    return await db.query("""
        SELECT DATE(created_at) as date,
               COUNT(*) as orders,
               SUM(amount) as revenue
        FROM orders
        WHERE user_id = $1
        GROUP BY DATE(created_at)
    """, user_id)

const { cachee } = require('@cachee/sdk');

// Example: Database query with intelligent caching
const getUser = cachee.cache({
  key: 'user:{user_id}',
  ttlStrategy: 'adaptive',
  prefetchRelated: true
})(async (userId) => {
  const result = await db.query(
    'SELECT * FROM users WHERE id = $1',
    [userId]
  );
  return result;
});

// Example: API call with fallback
const callExternalAPI = cachee.cache({
  key: 'external_api:{endpoint}',
  fallbackOnError: true,
  staleWhileRevalidate: 60
})(async (endpoint) => {
  const response = await fetch(`https://api.example.com/${endpoint}`);
  return response.json();
});

// Usage
const user = await getUser(123);
console.log('User:', user);

package main

import (
    "github.com/cachee-ai/go-sdk"
)

// GetUser fetches user with intelligent caching
func GetUser(userID int) (*User, error) {
    return cachee.Cache(&cachee.CacheOptions{
        Key:             fmt.Sprintf("user:%d", userID),
        TTLStrategy:     "adaptive",
        PrefetchRelated: true,
    }, func() (*User, error) {
        var user User
        err := db.QueryRow(
            "SELECT * FROM users WHERE id = $1",
            userID,
        ).Scan(&user)
        return &user, err
    })
}

// CallExternalAPI with fallback
func CallExternalAPI(endpoint string) (map[string]interface{}, error) {
    return cachee.Cache(&cachee.CacheOptions{
        Key:                   fmt.Sprintf("external_api:%s", endpoint),
        FallbackOnError:       true,
        StaleWhileRevalidate: 60,
    }, func() (map[string]interface{}, error) {
        resp, err := http.Get("https://api.example.com/" + endpoint)
        if err != nil {
            return nil, err
        }
        defer resp.Body.Close()

        var data map[string]interface{}
        json.NewDecoder(resp.Body).Decode(&data)
        return data, nil
    })
}

import ai.cachee.annotations.Cache;

public class UserService {

    @Cache(
        key = "user:{userId}",
        ttlStrategy = "adaptive",
        prefetchRelated = true
    )
    public User getUser(int userId) {
        return db.query(
            "SELECT * FROM users WHERE id = ?",
            userId
        );
    }

    @Cache(
        key = "external_api:{endpoint}",
        fallbackOnError = true,
        staleWhileRevalidate = 60
    )
    public JsonObject callExternalAPI(String endpoint) {
        HttpResponse response = httpClient.send(
            HttpRequest.newBuilder()
                .uri(URI.create("https://api.example.com/" + endpoint))
                .build(),
            HttpResponse.BodyHandlers.ofString()
        );
        return JsonParser.parseString(response.body()).getAsJsonObject();
    }
}

cachee-cli show-metrics --period 30d

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
📊 Performance Metrics (Last 30 Days)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Cache Hit Rate:     94.3% ↑ (from 62%)
Avg Latency:        6ms ↓ (from 48ms)
P99 Latency:        12ms ↓ (from 125ms)

💰 Cost Impact:
Monthly Savings:    $4,200 (42% reduction)
ROI:                1,850%
Uptime:             99.97%

🤖 AI Performance:
Predictions:        98.7% accurate
Cache Warming:      1.2M pre-fetches
Auto-optimizations: 847 TTL adjustments

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━