slack-memory-retrieval

Slack Memory Retrieval

This skill enables AI employees to efficiently retrieve and utilize stored memories to provide context-aware responses in Slack conversations.

Core Purpose

Retrieve relevant memories from {memories_path} to inform the next response with appropriate context about people, projects, decisions, preferences, and work history.

Quick Start

Basic Workflow

Every memory retrieval follows this pattern:

1. Analyze context - Extract channel, user, keywords from conversation
2. Read index.md - Get overview of available memories
3. Identify relevant files - Based on context and index
4. Load memories - Read specific files needed
5. Synthesize response - Combine memories with current context

Example: Simple Query

User (in #마케팅팀): "Q4 전략 어떻게 되고 있어?"

Step 1: Context Analysis
- Channel: #마케팅팀 (C123)
- Keywords: Q4, 전략

Step 2: Read Index
view {memories_path}/index.md
→ See Recent Updates, locate Q4-related items

Step 3: Load Relevant Files
view {memories_path}/channels/C123_마케팅팀.md
view {memories_path}/projects/Q4전략.md
view {memories_path}/meetings/ (find Q4 meetings)

Step 4: Respond
Synthesize information from channel context, project status, and meeting notes

Memory Structure

The memory system uses a hybrid approach:

Profile Files (One Per Entity)

• channels/C123_마케팅팀.md - Channel guidelines, preferences, static info
• users/U456_김철수.md - User profile, communication style

Topic Files (Multiple Per Category)

• projects/신제품런칭.md - Project discussions
• decisions/AWS전환_20251117.md - Important decisions
• meetings/2025-11-17-Q4회의.md - Meeting notes
• misc/마케팅팀_일상_20251117.md - Casual conversations

Directory Structure

{memories_path}/
├── index.md              # START HERE - navigation and stats
├── channels/             # Channel profile files (one per channel)
├── users/                # User profile files (one per user)
├── projects/             # Project topic files (multiple)
├── tasks/                # Task records
├── decisions/            # Decision records (date-stamped)
├── meetings/             # Meeting notes (date-stamped)
├── feedback/             # User feedback
├── announcements/        # Important announcements
├── resources/            # Internal docs and guides
├── external/news/        # External information
└── misc/                 # Uncategorized conversations

Essential Rules

Always Start with Index

CRITICAL: Every retrieval session must begin by reading index.md:

view {memories_path}/index.md

The index provides:

• Navigation structure
• Statistics (total channels, users, active projects)
• Recent updates (10 most recent changes)
• Quick links to key information

This one-time read gives you the complete map of available memories.

Context-Driven Retrieval

Extract context from the conversation:

Channel Context:

Message in #마케팅팀 
→ Load: {memories_path}/channels/C123_마케팅팀.md
→ Check related_to metadata for connected info

User Context:

DM from @chulsoo
→ Load: {memories_path}/users/U123_김철수.md
→ Get communication_style, preferences

Project Context:

Question about "신제품 런칭"
→ Load: {memories_path}/projects/신제품런칭.md
→ Check milestones, status, participants

Keyword Context:

Question mentions "결정", "승인"
→ Search: {memories_path}/decisions/
→ Find relevant decision files

Efficient Loading Strategy

Tier 1: Always Load (if relevant)

• index.md (overview)
• Current channel file (if in channel)
• Current user file (if DM or mentioned)

Tier 2: Load as Needed

• Project files (if project mentioned)
• Decision files (if asking about decisions)
• Meeting notes (if asking about meetings)

Tier 3: Load Selectively

• Tasks (only if specifically asked)
• Resources (only if referenced)
• External news (only if relevant)

Don't over-fetch. Use directory listings first:

view {memories_path}/projects/
# See available projects before loading specific files

Retrieval Patterns

Pattern 1: Channel Response

When responding in a channel:

# 1. Load channel context
view {memories_path}/channels/{channel_id}_{channel_name}.md

# 2. Check for channel guidelines
# Extract: tone, response_time, key_topics

# 3. Apply guidelines to response
# Adjust tone, format based on channel preferences

Pattern 2: User-Specific Response

When responding to a specific user:

# 1. Load user profile
view {memories_path}/users/{user_id}_{name}.md

# 2. Check communication_style
# Extract: tone, detail_level, preferences

# 3. Personalize response
# Match user's preferred style and detail level

Pattern 3: Project Status Query

When asked about project status:

# 1. Find project file
view {memories_path}/projects/
view {memories_path}/projects/{project_name}.md

# 2. Check metadata
# status, priority, milestones, participants

# 3. Get related info
# Check related_to for decisions, meetings

# 4. Provide comprehensive update
# Current status + recent activity + next steps

Pattern 4: Decision History

When asked about past decisions:

# 1. Search decisions
view {memories_path}/decisions/

# 2. Load relevant decision file
view {memories_path}/decisions/{decision_name}.md

# 3. Extract key info
# decision_makers, rationale, alternatives_considered

# 4. Explain context
# Why decision was made + alternatives + outcome

Pattern 5: Task History

When asked about completed work:

# 1. Check completed tasks
view {memories_path}/tasks/completed/

# 2. Filter by assignee/date
# Look for relevant assignee, date range

# 3. Summarize work
# List tasks + effort + outcomes

Advanced Techniques

Cross-Referencing

Follow the trail of related information:

# In project file:
---
related_to:
  - decisions/기술스택선택.md
  - meetings/2025-10-20-기획회의.md
---

Load related files to build complete context.

Metadata Filtering

Use metadata to filter without reading entire files:

# List directory first
view {memories_path}/projects/

# Check filenames and metadata
# Only load files matching criteria:
# - status: in_progress
# - priority: high
# - participants: includes current_user

Temporal Context

Consider time-sensitivity:

# Recent Updates in index.md
→ Shows 10 most recent changes
→ Focus on these for "latest" questions

# File metadata: created, updated
→ Check dates to prioritize fresh info

Tag-Based Discovery

Use tags for discovery:

tags: [urgent, marketing, q4, approval-needed]

When user asks about "urgent items":

• Scan files for tags: urgent
• Collect across categories
• Present by priority

Response Construction

Synthesize, Don't Dump

❌ Bad:

"According to channels/마케팅팀.md, the response time is 1 hour.
According to projects/Q4전략.md, the status is in_progress.
According to meetings/기획회의.md..."

✅ Good:

"Q4 마케팅 전략은 현재 진행 중이며, 지난 기획회의에서 
주요 방향을 확정했습니다. 현재 MVP 개발 단계에 있고..."

Synthesize information naturally without explicitly citing sources.

Apply Context Appropriately

Channel Guidelines: If channel specifies "간결한 답변", keep response concise.

User Preferences: If user prefers "bullet points", format accordingly.

Project Status: Include relevant status without over-explaining.

Maintain Conversational Flow

Integrate memories seamlessly into natural conversation:

User: "이번 주 미팅 어땠어?"

Response: "화요일 기획회의에서 신규 기능 3개를 최종 확정했어요. 
전반적으로 개발 일정에 대한 우려가 있었지만, 리소스 조정으로 
해결 가능할 것으로 보입니다."

(Draws from: meetings/기획회의.md + projects/신규기능.md)

Important Guardrails

What to Retrieve

✅ Do retrieve:

• Channel communication guidelines
• User preferences and profiles
• Project status and history
• Decision rationale and history
• Meeting notes and action items
• Completed task history
• Feedback and suggestions
• Resource documents

What NOT to Retrieve

❌ Don't retrieve:

• Information outside {memories_path}
• System configuration files
• Scheduling requests (handled by scheduler agent)
• Agent identity info (name, org, team)

Privacy and Access

• Only access files within {memories_path}
• Don't share sensitive information inappropriately
• Respect access_level metadata if present

Efficiency

• Don't load unnecessary files
• Use directory listings before file reads
• Start with index.md, not individual files
• Follow the efficient loading strategy (Tier 1 → Tier 2 → Tier 3)

Troubleshooting

Issue: Can't find relevant memory

Solution:

1. Check index.md for recent updates
2. Search broader category (e.g., misc/)
3. Check related_to in similar files
4. Inform user if information not available

Issue: Conflicting information

Solution:

1. Prioritize newer information (check updated timestamp)
2. Consider context of each source
3. Mention both perspectives if relevant

Issue: Too much information

Solution:

1. Prioritize by relevance to current question
2. Summarize rather than detail
3. Focus on actionable insights

Issue: Memory seems outdated

Solution:

1. Check updated timestamp
2. Look for newer related files
3. Note timeframe in response
4. Suggest updating if critical

Integration with Memory Management

This skill works in tandem with slack-memory-store:

Memory Management (separate agent):

• Stores new information
• Updates existing memories
• Maintains index

Memory Retrieval (this skill):

• Reads stored information
• Finds relevant context
• Informs responses

These are complementary skills for a complete memory system.

Best Practices Summary

1. Always start with index.md - Get the map before exploring
2. Extract context first - Channel, user, keywords guide retrieval
3. Load efficiently - Directory listing → relevant files only
4. Follow references - Use related_to metadata
5. Synthesize naturally - Don't cite sources explicitly

---

Content truncated.