npm package: @stcky.ai/stcky
Description: Cross-AI memory SDK. Add persistent memory to any AI app in 5 minutes.
Author: STCKY
Latest version: 1.0.0

# STCKY 🧠

**Cross-AI memory. Add persistent memory to any AI app in 5 minutes.**

Your AI knows a lot. Just nothing about you.  
Until now.

```bash
npm install stcky
```

## Quick Start

```javascript
const stcky = require('stcky')('your_api_key');

// Get context for a user
const { context } = await stcky.getContext();
// → "User prefers concise responses. Working on STCKY project. Uses Vercel."

// Remember something explicitly
await stcky.remember('user123', {
  category: 'preference',
  key: 'response_style',
  value: 'concise and direct'
});

// Auto-learn from conversations
await stcky.learn('user123', 
  "I'm building an AI startup called STCKY",
  "Great! What tech stack are you using?"
);
```

## Magic Wrapper (The Real Power)

Wrap your OpenAI or Anthropic client. Memory happens automatically.

```javascript
const { createClient } = require('stcky');
const OpenAI = require('openai');

const stcky = createClient('your_stcky_key');
const openai = new OpenAI({ apiKey: 'your_openai_key' });

// Wrap it
const ai = stcky.wrap(openai, { userId: 'user123' });

// Use it normally - STCKY handles memory
const response = await ai.chat.completions.create({
  model: 'gpt-4',
  messages: [{ role: 'user', content: 'Help me design my database' }]
});

// ✅ Context injected automatically
// ✅ Conversation learned automatically
// ✅ Next session, the AI remembers
```

Works with Anthropic too:

```javascript
const Anthropic = require('@anthropic-ai/sdk');

const anthropic = new Anthropic({ apiKey: 'your_anthropic_key' });
const ai = stcky.wrap(anthropic, { userId: 'user123' });

const response = await ai.messages.create({
  model: 'claude-3-opus-20240229',
  messages: [{ role: 'user', content: 'What tech stack should I use?' }]
});

// If you told ChatGPT yesterday, Claude knows today.
```

## Why STCKY?

**The Problem:**
- ChatGPT memory only works in ChatGPT
- Claude memory only works in Claude
- Gemini memory only works in Gemini
- They'll never share with each other

**The Solution:**
- One memory layer that works everywhere
- Tell Claude once, ChatGPT knows
- Your users' context follows them across AI tools

## API Reference

### `stcky.getContext(userId?, query?)`

Get relevant memories for context injection.

```javascript
const { context, memories } = await stcky.getContext('user123', 'database preferences');
```

### `stcky.remember(userId, memory)`

Explicitly store a memory.

```javascript
await stcky.remember('user123', {
  category: 'decision',      // preference, project, decision, person, pending, reference
  key: 'database-choice',
  value: 'Using Supabase for the backend',
  tags: 'tech,infrastructure',           // optional
  relevantDate: '2026-04-15T00:00:00Z'   // optional, for time-sensitive items
});
```

### `stcky.learn(userId, userMessage, assistantResponse)`

Let STCKY extract what's worth remembering.

```javascript
await stcky.learn('user123',
  "I decided to use Vercel for hosting",
  "Great choice! Vercel works well with Next.js..."
);
// STCKY extracts: decision → hosting → Vercel
```

### `stcky.wrap(client, options)`

Wrap OpenAI or Anthropic client for automatic memory.

```javascript
const ai = stcky.wrap(openai, { 
  userId: 'user123',
  autoLearn: true  // default: true
});
```

## Get Your API Key

1. Go to [getstcky.com](https://getstcky.com)
2. Sign up (free tier: 100 memories)
3. Get your API key
4. Add memory to your AI in 5 minutes

## Pricing

- **Free**: 100 memories, perfect for testing
- **Pro**: $9/mo, unlimited memories
- **Team**: $29/seat/mo, shared memory + admin controls

## The Vision

> "Why build memory when STCKY already solved it?"

STCKY is the memory layer for AI. Like Stripe for payments, but for AI memory.

One key. Every AI. Memory that follows your users.

---

**Links:**
- Website: [getstcky.com](https://getstcky.com)
- Docs: [docs.stcky.ai](https://docs.stcky.ai)
- Support: steven@stcky.ai

MIT License © 2026 STCKY