Cache

import { MemoryCache } from '@orka-js/cache';
 
const cache = new MemoryCache({
  maxSize: 1000,         // Maximum number of entries (default: 1000)
  ttlMs: 1000 * 60 * 30, // Time-to-live: 30 minutes (optional)
  namespace: 'my-app'    // Key prefix for isolation (optional)
});
 
// Basic operations
await cache.set('key', { data: 'value' });
const value = await cache.get('key');       // { data: 'value' }
const exists = await cache.has('key');      // true
await cache.delete('key');
await cache.clear();
 
// Get cache statistics
const stats = cache.getStats();
console.log(stats);
// { hits: 42, misses: 8, size: 150, hitRate: 0.84 }

import { RedisCache } from '@orka-js/cache';
 
const cache = new RedisCache({
  url: 'redis://localhost:6379',  // Redis connection URL
  keyPrefix: 'orka:',             // Key prefix (default: 'orka:')
  ttlMs: 1000 * 60 * 60,         // TTL: 1 hour (optional)
});
 
// Connect to Redis (auto-connects on first operation)
await cache.connect();
 
// Same API as MemoryCache
await cache.set('key', { data: 'value' });
const value = await cache.get('key');
 
// Disconnect when done
await cache.disconnect();

import { OpenAIAdapter } from '@orka-js/openai';
import { MemoryCache } from '@orka-js/cache';
import { CachedLLM } from '@orka-js/cache';
 
// 1. Create your LLM adapter
const llm = new OpenAIAdapter({
  apiKey: process.env.OPENAI_API_KEY!,
  model: 'gpt-4o-mini'
});
 
// 2. Create a cache store
const cache = new MemoryCache({ maxSize: 500, ttlMs: 1000 * 60 * 30 });
 
// 3. Wrap with CachedLLM
const cachedLLM = new CachedLLM(llm, cache, {
  ttlMs: 1000 * 60 * 60  // Override TTL: cache for 1 hour
});
 
// First call — hits the API (~800ms)
const result1 = await cachedLLM.generate('What is TypeScript?');
console.log(result1.content); // "TypeScript is a typed superset..."
 
// Second call — instant from cache (~0ms)
const result2 = await cachedLLM.generate('What is TypeScript?');
console.log(result2.content); // Same response, from cache
 
// Use in Orka config — transparent replacement
import { createOrka } from 'orkajs';
 
const orka = createOrka({
  llm: cachedLLM,  // ← Drop-in replacement
  vectorDB: /* ... */
});
 
// All orka.ask(), orka.generate(), etc. now use caching
const answer = await orka.ask({
  question: 'What is TypeScript?',
  knowledge: 'docs'
});

import { OpenAIAdapter } from '@orka-js/openai';
import { MemoryCache } from '@orka-js/cache';
import { CachedEmbeddings } from '@orka-js/cache';
 
const llm = new OpenAIAdapter({ apiKey: process.env.OPENAI_API_KEY! });
const cache = new MemoryCache({ maxSize: 10000 });
 
const cachedEmbed = new CachedEmbeddings(llm, cache, {
  ttlMs: 1000 * 60 * 60 * 24  // Cache embeddings for 24 hours
});
 
// First call — computes all 3 embeddings via API
const embeddings1 = await cachedEmbed.embed([
  'Hello world',
  'TypeScript is great',
  'Orka AI framework'
]);
 
// Second call — all 3 from cache (0 API calls)
const embeddings2 = await cachedEmbed.embed([
  'Hello world',
  'TypeScript is great',
  'Orka AI framework'
]);
 
// Mixed call — only "New text" hits the API, others from cache
const embeddings3 = await cachedEmbed.embed([
  'Hello world',      // ← from cache
  'New text here',    // ← API call
  'Orka AI framework' // ← from cache
]);

import { createOrka, OpenAIAdapter } from '@orka-js/core';
import { RedisCache } from '@orka-js/cache';
import { CachedLLM } from '@orka-js/cache';
import { CachedEmbeddings } from '@orka-js/cache';
 
// Shared Redis cache
const redisCache = new RedisCache({
  url: process.env.REDIS_URL!,  // e.g. 'redis://redis:6379'
  keyPrefix: 'orka:prod:',
  ttlMs: 1000 * 60 * 60 * 4     // 4 hours
});
 
const llm = new OpenAIAdapter({
  apiKey: process.env.OPENAI_API_KEY!,
  model: 'gpt-4o-mini'
});
 
// Cache both LLM responses and embeddings
const cachedLLM = new CachedLLM(llm, redisCache);
const cachedEmbed = new CachedEmbeddings(llm, redisCache);
 
const orka = createOrka({
  llm: cachedLLM,
  vectorDB: /* ... */
});
 
// All operations now use Redis-backed caching
const result = await orka.ask({
  question: 'How do I deploy my app?',
  knowledge: 'documentation'
});
 
// Monitor cache performance
const stats = redisCache.getStats();
console.log(`Cache hit rate: ${(stats.hitRate * 100).toFixed(1)}%`);
 
// Cleanup on shutdown
process.on('SIGTERM', async () => {
  await redisCache.disconnect();
});

import type { CacheStore } from '@orka-js/cache';
 
class DynamoDBCache implements CacheStore {
  readonly name = 'dynamodb-cache';
 
  async get<T>(key: string): Promise<T | undefined> {
    // Your DynamoDB get logic
  }
 
  async set<T>(key: string, value: T, ttlMs?: number): Promise<void> {
    // Your DynamoDB put logic
  }
 
  async delete(key: string): Promise<boolean> {
    // Your DynamoDB delete logic
  }
 
  async clear(): Promise<void> {
    // Your DynamoDB scan + delete logic
  }
 
  async has(key: string): Promise<boolean> {
    // Your DynamoDB exists check
  }
}
 
// Use with CachedLLM
const cache = new DynamoDBCache();
const cachedLLM = new CachedLLM(llm, cache);

// ✅ Import only what you need
import { MemoryCache } from '@orka-js/cache';
import { CachedLLM } from '@orka-js/cache';
 
// ✅ Or import from index
import { MemoryCache, RedisCache, CachedLLM, CachedEmbeddings } from '@orka-js/cache';