Recall - Search Knowledge Graph

Search past decisions and patterns from the knowledge graph with optional cloud semantic search enhancement.

Graph-First Architecture (v2.1)

The recall skill uses graph memory as PRIMARY search:

• Knowledge Graph (PRIMARY): Entity and relationship search via mcp__memory__search_nodes

• FREE, zero-config, always works

• Semantic Memory (mem0): Optional cloud search via search-memories.py script - requires MEM0_API_KEY, use with --mem0 flag

Benefits of Graph-First:

• Zero configuration required - works out of the box

• Explicit entity and relationship queries

• Fast local search with no network latency

• No cloud dependency for basic operation

• Optional cloud enhancement with --mem0 flag for semantic similarity search

Overview

• Finding past architectural decisions

• Searching for recorded patterns

• Looking up project context

• Retrieving stored knowledge

• Querying cross-project best practices

• Finding entity relationships

Usage

/recall <search query> /recall --category <category> <search query> /recall --limit <number> <search query>

Cloud-enhanced search (v2.1.0+)

/recall --mem0 <query> # Search BOTH graph AND mem0 cloud /recall --mem0 --limit 20 <query> # More results from both systems

Scoped search

/recall --agent <agent-id> <query> # Filter by agent scope /recall --global <query> # Search cross-project best practices

Advanced Flags

Flag Behavior

(default) Search graph only

--mem0

Search BOTH graph and mem0 cloud

--limit <n>

Max results (default: 10)

--category <cat>

Filter by category

--agent <agent-id>

Filter results to a specific agent's memories

--global

Search cross-project best practices

Context-Aware Result Limits (CC 2.1.6)

Result limits automatically adjust based on context_window.used_percentage :

Context Usage Default Limit Behavior

0-70% 10 results Full results with details

70-85% 5 results Reduced, summarized results

85% 3 results Minimal with "more available" hint

Workflow

1. Parse Input

Check for --category <category> flag Check for --limit <number> flag Check for --mem0 flag → search_mem0: true Check for --agent <agent-id> flag → filter by agent_id Check for --global flag → search global scope Extract the search query

2. Search Knowledge Graph (PRIMARY)

Use mcp__memory__search_nodes :

{ "query": "user's search query" }

Knowledge Graph Search:

• Searches entity names, types, and observations

• Returns entities with their relationships

• Finds patterns like "X uses Y", "X recommends Y"

Entity Types to Look For:

• Technology : Tools, frameworks, databases (pgvector, PostgreSQL, React)

• Agent : OrchestKit agents (database-engineer, backend-system-architect)

• Pattern : Named patterns (cursor-pagination, connection-pooling)

• Decision : Architectural decisions

• Project : Project-specific context

• AntiPattern : Failed patterns

3. Search mem0 (OPTIONAL - only if --mem0 flag)

Skip if --mem0 flag NOT set or MEM0_API_KEY not configured.

Execute the script IN PARALLEL with step 2:

!bash skills/mem0-memory/scripts/crud/search-memories.py
--query "user's search query"
--user-id "orchestkit-{project-name}-decisions"
--limit 10
--enable-graph

User ID Selection:

• Default: orchestkit-{project-name}-decisions

• With --global : orchestkit-global-best-practices

Filter Construction:

• Always include user_id filter

• With --category : Add { "metadata.category": "{category}" } to AND array

• With --agent : Add { "agent_id": "ork:{agent-id}" } to AND array

4. Merge and Deduplicate Results (if --mem0)

Only when both systems return results:

• Collect results from both systems

• For each mem0 memory, check if its text matches a graph entity observation

• If matched, mark as [CROSS-REF] and merge metadata

• Remove pure duplicates (same content from both systems)

• Sort: graph results first, then mem0 results, cross-refs highlighted

5. Format Results

Graph-Only Results (default):

🔍 Found {count} results matching "{query}":

[GRAPH] {entity_name} ({entity_type}) → {relation1} → {target1} → {relation2} → {target2} Observations: {observation1}, {observation2}

[GRAPH] {entity_name2} ({entity_type2}) Observations: {observation}

With --mem0 (combined results):

🔍 Found {count} results matching "{query}":

[GRAPH] {entity_name} ({entity_type}) → {relation} → {target} Observations: {observation}

[GRAPH] {entity_name2} ({entity_type2}) Observations: {observation}

[MEM0] [{time ago}] ({category}) {memory text}

[MEM0] [{time ago}] ({category}) {memory text}

[CROSS-REF] {memory text} (linked to {N} graph entities) 📊 Linked entities: {entity1}, {entity2}

With --mem0 when MEM0_API_KEY not configured:

🔍 Found {count} results matching "{query}":

[GRAPH] {entity_name} ({entity_type}) → {relation} → {target} Observations: {observation}

⚠️ mem0 search requested but MEM0_API_KEY not configured (graph-only results)

High Context Pressure (>85%):

🔍 Found 12 matches (showing 3 due to context pressure at 87%)

[GRAPH] pgvector (Technology) → USED_FOR → RAG [GRAPH] cursor-pagination (Pattern) [GRAPH] database-engineer (Agent) → RECOMMENDS → pgvector

More results available. Use /recall --limit 10 to override.

6. Handle No Results

🔍 No results found matching "{query}"

Searched: • Knowledge graph: 0 entities

Try: • Broader search terms • /remember to store new decisions • --global flag to search cross-project best practices • --mem0 flag to include cloud semantic search

Time Formatting

Duration Display

< 1 day "today"

1 day "yesterday"

2-7 days "X days ago"

1-4 weeks "X weeks ago"

4 weeks "X months ago"

Examples

Basic Graph Search

Input: /recall database

Output:

🔍 Found 3 results matching "database":

[GRAPH] PostgreSQL (Technology) → CHOSEN_FOR → ACID-requirements → USED_WITH → pgvector Observations: Chosen for ACID requirements and team familiarity

[GRAPH] database-engineer (Agent) → RECOMMENDS → pgvector → RECOMMENDS → cursor-pagination Observations: Uses pgvector for RAG applications

[GRAPH] cursor-pagination (Pattern) Observations: Scales well for large datasets

Category Filter

Input: /recall --category architecture API

Output:

🔍 Found 2 results matching "API" (category: architecture):

[GRAPH] api-gateway (Architecture) → IMPLEMENTS → rate-limiting → USES → JWT-authentication Observations: Central entry point for all services

[GRAPH] REST-API (Pattern) → FOLLOWS → OpenAPI-spec Observations: Standard for external-facing APIs

Cloud-Enhanced Search

Input: /recall --mem0 database

Output:

🔍 Found 5 results matching "database":

[GRAPH] PostgreSQL (Technology) → CHOSEN_FOR → ACID-requirements Observations: Chosen for ACID requirements

[GRAPH] database-engineer (Agent) → RECOMMENDS → pgvector Observations: Uses pgvector for RAG

[MEM0] [2 days ago] (decision) PostgreSQL chosen for ACID requirements and team familiarity

[MEM0] [1 week ago] (pattern) Database connection pooling with pool_size=10, max_overflow=20

[CROSS-REF] [3 days ago] pgvector for RAG applications (linked to 2 entities) 📊 Linked: database-engineer, pgvector

Agent-Scoped Search

Input: /recall --agent backend-system-architect "API patterns"

Output:

🔍 Found 2 results from backend-system-architect:

[GRAPH] backend-system-architect (Agent) → RECOMMENDS → cursor-pagination → RECOMMENDS → repository-pattern Observations: Use versioned endpoints: /api/v1/, /api/v2/

[GRAPH] repository-pattern (Pattern) Observations: Separate controllers, services, and repositories

Cross-Project Search

Input: /recall --global --category pagination

Output:

🔍 Found 3 GLOBAL best practices (pagination):

[GRAPH] cursor-pagination (Pattern) → SCALES_FOR → large-datasets → PREFERRED_OVER → offset-pagination Observations: From project: ecommerce, analytics, cms

[GRAPH] keyset-pagination (Pattern) → USED_FOR → real-time-feeds Observations: From project: analytics

[GRAPH] offset-pagination (AntiPattern) Observations: Caused timeouts on 1M+ rows

Relationship Query

Input: /recall what does database-engineer recommend

Output:

🔍 Found relationships for database-engineer:

[GRAPH] database-engineer (Agent) → RECOMMENDS → pgvector → RECOMMENDS → cursor-pagination → RECOMMENDS → connection-pooling → USES → PostgreSQL Observations: Specialist in database architecture

Related Skills

• remember: Store information for later recall

Error Handling

• If knowledge graph unavailable, show configuration instructions

• If --mem0 requested without MEM0_API_KEY, proceed with graph-only and notify user

• If search query empty, show recent entities instead

• If no results, suggest alternatives

• If --agent used without agent-id, show available agents

• If --global returns no results, suggest storing with /remember --global

• If --mem0 returns partial results (mem0 failed), show graph results with degradation notice