Memory Search

What Is Memory Search?

Memory Search is a productivity skill for the Happycapy Skills platform that enables users to efficiently search and retrieve information from claude-mem's persistent, cross-session memory database. Unlike conventional session-based search tools, Memory Search is designed to help users locate and reference work completed in previous sessions, making it ideal for users who need to revisit past decisions, solutions, or project states. The skill operates using a streamlined three-step workflow: search, filter, and fetch. This approach maximizes efficiency by preventing unnecessary data retrieval and reducing token consumption during interactions.

Memory Search is best suited for scenarios where historical context or continuity is critical, such as tracking bug fixes, referencing previous architectural decisions, or reviewing past feature implementations. By leveraging this skill, users can maintain a cohesive understanding of ongoing projects and avoid duplicating previous work.

Why Use Memory Search?

The primary advantage of Memory Search lies in its ability to cut through the clutter of multiple sessions and provide direct access to relevant past work. In collaborative environments or long-term projects, details can easily be lost across sessions or buried under new updates. Memory Search addresses this challenge by:

• Providing a searchable index of all past sessions and observations.
• Allowing users to filter results based on specific parameters such as project, type of work, or date range.
• Enabling precise fetching of details only after relevant items have been identified, which greatly optimizes token usage and speeds up workflows.

For users who frequently find themselves asking, "Did we already solve this?" or "How did we do this last time?", Memory Search provides a systematic solution that integrates seamlessly into the Happycapy productivity suite.

How to Use Memory Search

Memory Search is built around a disciplined three-step workflow that must be strictly followed for optimal performance and efficiency. The steps are: search, filter, and fetch.

Step 1:

Search - Obtain the Index

The search step is the entry point for all queries. Use the search MCP (Memory Command Protocol) tool to retrieve a concise index of potentially relevant records. This index includes metadata such as record IDs, timestamps, types, and titles, but not the full content of each record.

Example Search Command

search(query="authentication", limit=20, project="my-project")

Returned Data Structure:

| ID     | Time    | T   | Title                        | Read |
|--------|---------|-----|------------------------------|------|
| #11131 | 3:48 PM |   | Added JWT authentication     | ~75  |
| #10942 | 2:15 PM |   | Fixed auth token expiration  | ~50  |

Parameters:

• query (string): The search term to use (e.g., "authentication").
• limit (number): Maximum number of results to return (default 20, maximum 100).
• project (string): Filter by project name.
• type (string, optional): Limit results to "observations", "sessions", or "prompts".
• obs_type (string, optional): Further filter observations by type such as bugfix, feature, decision, discovery, or change.
• dateStart (string, optional): Only include records after this date (format: YYYY-MM-DD or epoch milliseconds).
• dateEnd (string, optional): Only include records before this date (format: YYYY-MM-DD or epoch milliseconds).
• offset (number, optional): Skip the first N results.

Step 2:

Filter - Identify Relevant Records

After retrieving the search index, carefully examine the returned records to identify which entries are most relevant to your current query. Do not fetch full details for all records. Only proceed to the fetch step for those records that match your requirements. This filtering step is critical to avoid unnecessary data transfer and token usage.

Step 3:

Fetch - Retrieve Full Details

Once you have identified the specific record(s) of interest using their IDs, use the designated fetch command to retrieve the full content. By strictly filtering before fetching, you minimize data transfer and keep interactions efficient.

Example Fetch Command:

fetch(id=11131)

This will return the detailed content for the record with ID #11131, allowing you to review the full context or solution as it was captured in the previous session.

When to Use Memory Search

Memory Search should be employed whenever you need to reference or retrieve information from past sessions, including but not limited to the following scenarios:

• Answering questions like "Did we already fix this?", "How did we solve X last time?", or "What happened last week?"
• Reviewing previous bug fixes, feature implementations, or architectural decisions.
• Conducting retrospectives or audits of project progress.
• Ensuring continuity in long-running projects or when onboarding new team members.

It is not intended for use within the current conversation. Instead, its value lies in accessing persistent knowledge accumulated over time.

Important Notes

• Always Follow the Workflow: The search -> filter -> fetch process is mandatory. Never fetch full details without first narrowing down the candidates via search and filter. Failing to do so can result in excessive token usage and slower response times.
• Efficiency is Critical: Filtering before fetching can reduce token consumption by up to tenfold, especially in large projects with extensive histories.
• Parameter Usage: Make use of the available search parameters to target your queries effectively. Filtering by project, type, or date can significantly improve result relevance and performance.
• Not for Current Sessions: Use Memory Search only for previous sessions or observations, not for content in the current conversation.
• Professional Environment: Memory Search is designed for technical and professional settings where project continuity and knowledge management are essential.

By adhering to these guidelines and leveraging the structured workflow of Memory Search, users can maintain a robust memory of project history, accelerate problem-solving, and ensure that valuable knowledge is never lost across sessions.