PersistQ Logo
PersistQ

Make Your Claude Skills Remember

Give your Anthropic Skills persistent memory. Enable them to recall user preferences, learn from past interactions, and provide increasingly personalized assistance across sessions.

In 60 seconds:

PersistQ gives your Claude Skills persistent memory. Your Skills can remember user preferences, past conversations, and learn from interactions - making them smarter over time. Works seamlessly with Claude.ai, Claude Code, and the Claude API.

Why Skills Need Memory

Anthropic Skills are modular folders of instructions that Claude loads dynamically. They're powerful, but stateless - each invocation starts fresh.

❌Without Memory

  • •Claude forgets your coding style every session
  • •Customer support restarts context each time
  • •You repeat preferences and requirements constantly
  • •Skills can't learn from past mistakes or feedback

✅With PersistQ Memory

  • •Remembers you prefer functional React, no semicolons
  • •Recalls past issues and provides faster resolutions
  • •Learns your preferences once, applies them forever
  • •Improves continuously from every interaction

Anthropic Skills

  • Folders with SKILL.md instructions
  • Loaded dynamically when needed
  • Work across Claude.ai, Code, and API

+ PersistQ Memory

  • Persistent context across sessions
  • Learn from user interactions
  • Personalized, improving responses

See It In Action

Here's how a Customer Support Skill uses PersistQ to remember user context and provide better service:

Example Scenario

First Interaction - Monday

User:

"I'm having trouble logging in with 2FA"

Skill Process:

  • • Searches for user history (none found - new user)
  • • Helps troubleshoot 2FA issue
  • • Stores: User prefers step-by-step instructions, had 2FA problems
Second Interaction - Friday (Same Week)

User:

"I'm locked out again"

Skill Process:

  • • Recalls: User had 2FA issues before, prefers detailed steps
  • • Immediately provides targeted 2FA troubleshooting with step-by-step guide
  • • Updates: This is a recurring issue, may need account review
Third Interaction - Next Month

User:

"How do I update my billing info?"

Skill Process:

  • • Remembers: User's communication style preference (step-by-step)
  • • Provides billing update guide in familiar detailed format
  • • No need to re-establish preferences or context

Result:

Faster resolutions, personalized communication style, and proactive issue detection - all without the user repeating themselves.

Quick Start: Get Running in 5 Minutes

1

Get Your API Key

Sign up at PersistQ and grab your API key from the dashboard

export PERSISTQ_API_KEY="your-api-key-here"
2

Choose Your Integration Method

Two approaches - pick what works for you:

MCP Server (Recommended)

Best for Claude Desktop integration

  • ✓ Automatic tool exposure
  • ✓ Standardized interface
  • ✓ Better security

Direct API

Best for custom scripts & workflows

  • ✓ Full control
  • ✓ Simple HTTP calls
  • ✓ Any language
3

Create Your First Memory-Enabled Skill

Add memory operations to your SKILL.md:

---
name: my-memory-skill
description: A skill that remembers user preferences
---

# My Memory Skill

Before responding, search for user context:
- Use search_memory() to find past interactions
- Use add_memory() to store new learnings
- Use list_memories() to review recent history
4

Test It Out

Load your skill in Claude and watch it remember across conversations!

Need more details? Jump to MCP Integration or Direct API Integration sections below for complete setup instructions.

MCP Integration (Recommended)

The Model Context Protocol (MCP) approach exposes PersistQ as tool calls that Claude can use automatically. This is the cleanest and most maintainable integration method.

1. Install PersistQ MCP Package

Use our ready-to-use MCP server package - no need to build from scratch:

# Install our MCP server package
npm install @persistq/mcp-server

# Or using yarn
yarn add @persistq/mcp-server

📦 Complete package includes: Pre-built MCP server with all PersistQ tools, automatic tool exposure, and ready-to-use configuration templates.

2. Configure Claude Desktop

Add the MCP server to your Claude configuration:

// claude_desktop_config.json
{
  "mcpServers": {
    "persistq-memory": {
      "command": "npx",
      "args": ["@persistq/mcp-server"],
      "env": {
        "PERSISTQ_API_KEY": "your-api-key-here"
      }
    }
  }
}

💡 Pro tip: Using npx means you don't need to download or manage the server file - it runs directly from npm!


3. Create Your Skill

Write a SKILL.md that instructs Claude when and how to use the memory tools:

---
name: memory-assistant
description: Assistant with persistent memory across conversations
---

# Memory-Enhanced Assistant

## Memory Strategy

Before responding to any user request:
1. **Search** for relevant past interactions using search_memory()
2. **Consider** user preferences and context from memory
3. **Respond** with personalized, context-aware assistance
4. **Store** new learnings using add_memory()

## Example Usage

When user asks for coding help:
- Search for their coding style preferences
- Recall past projects and challenges
- Provide targeted assistance
- Store the interaction for next time

## Memory Categories

- user_preferences: Communication style, coding preferences
- learning_progress: Skills learned, topics covered
- project_context: Current projects, recurring patterns

That's it!

When you load this skill in Claude, it will automatically have access to the PersistQ memory tools and will use them according to your instructions. Claude knows when to search, store, and recall information based on your skill's guidance.

Direct API Integration

For custom scripts, workflows, or non-Claude environments, use the PersistQ API directly.

Install PersistQ SDK

Use our official SDKs for direct API integration:

JavaScript/TypeScript

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

Python

pip install persistq
# or
pip3 install persistq
// JavaScript/TypeScript Example
import { PersistQClient } from '@persistq/sdk';

const client = new PersistQClient({
  apiKey: process.env.PERSISTQ_API_KEY
});

// Store a memory
await client.addMemory({
  text: "User prefers TypeScript over JavaScript",
  topic: "preferences",
  metadata: { user_id: "user_123" }
});

// Search memories
const results = await client.searchMemory({
  query: "TypeScript preferences",
  topic: "preferences"
});

Full SDK documentation: Check our API Reference for Python, Go, and other language examples.

Best Practices

📁Organize by Topics

Use consistent topic names to categorize memories:

  • • user_context - Background, work, experience
  • • preferences - Communication, coding style
  • • learning_progress - Skills, topics covered
  • • problem_patterns - Issues, solutions

🏷️Use Rich Metadata

Add structured metadata for better filtering:

  • • user_id - Associate with specific users
  • • timestamps - Track when events occurred
  • • satisfaction - Rate interaction quality
  • • categories - Add custom tags

🔍Search Strategically

Always search before responding:

  • • Check for existing user context first
  • • Use topic filters to narrow results
  • • Search broadly, then refine
  • • Combine multiple searches for full context

💾Store Specific Memories

Make memories actionable and clear:

  • • Be specific, not vague
  • • Include context and outcomes
  • • Store after meaningful interactions
  • • Update outdated memories

Memory Lifecycle

1. Search2. Use Context3. Respond4. Store Learnings

Need Help?

API Reference

Detailed method documentation

Getting Started

Setup instructions and basics

Support

Contact us for integration questions