Recallium Concepts

What it stores: Implementation details, code changes, technical decisions about specific files.

Example: "Implemented JWT authentication with refresh token rotation using Redis for storage. Access tokens expire in 15 minutes, refresh tokens in 7 days."

Always linked to specific files so you can find past implementation notes before editing code.

What it stores: Architectural choices, technology selections, and the reasoning behind them.

Example: "Chose PostgreSQL over MongoDB because we need ACID transactions for financial data and complex relational queries for reporting."

Answers "why did we..." questions instantly, preventing repeated debates.

What it stores: Coding standards, preferences, constraints, and team conventions.

Example: "Always use TypeScript strict mode. Prefer functional components over class components. All API calls must include retry logic."

Acts as guardrails for your AI, ensuring consistent code quality across all suggestions.

What it stores: Insights, "aha" moments, lessons learned, and discoveries.

Example: "Discovered that useEffect dependency arrays must include all external variables to prevent stale closures. Missing dependencies cause subtle bugs."

Builds your team's collective knowledge, preventing the same mistakes twice.

What it stores: Bug investigations, root cause analysis, and troubleshooting notes.

Example: "Login fails with 500 error. Stack trace shows null pointer in session validation. Root cause: missing Redis connection check. Fixed by adding connection validation before session lookup."

Helps recognize and fix recurring issues faster by surfacing past solutions.

What it stores: Architecture explorations, system design discussions, and technical proposals.

Example: "Exploring caching strategies for the API: Redis for session data (fast, TTL support), Memcached for API responses (distributed, simple), considering tradeoffs between consistency and performance."

Captures the design thinking process, not just the final decision.

What it stores: Investigation findings, external references, and gathered information.

Example: "Research on OAuth2 PKCE flow: RFC 7636 defines Proof Key for Code Exchange to prevent authorization code interception. Recommended for mobile and SPA applications."

What it stores: Team conversations, meetings, code reviews, and feedback.

Example: "Team discussion on microservices migration: Decided to start with a modular monolith first. Concerns about operational complexity and team size. Will revisit in 6 months."

What it stores: Status updates, milestones, and checkpoint summaries.

Example: "Week 3 sprint: Completed authentication module (login, signup, password reset). Starting API integration next week. Blocked on database schema approval."

What it stores: Simple action item notes and TODOs.

Example: "TODO: Add error handling to login endpoint. Need to handle network failures and invalid credentials gracefully."

For formal task tracking with status management, use the dedicated Tasks feature instead.

What it stores: General notes, thoughts, and temporary information (default type).

Example: "Investigating performance issue in dashboard component. Load time is 3+ seconds. Suspects: large data fetches, unnecessary re-renders, missing memoization."

The default catch-all type when other categories don't fit.

What it stores: High-level overview documents describing project goals, scope, and current status.

Your project's executive summary that stakeholders reference for quick understanding.

What it stores: Detailed specifications of what needs to be built, including features and acceptance criteria.

Formal documentation that defines what the system will do and how success is measured.

What it stores: Technical architecture and development roadmaps showing how the system will be built.

Technical blueprints that guide the development team through the implementation process.

What it stores: Links between related projects to understand dependencies and discover related work across your codebase.

Connect projects together to see how different systems and initiatives relate to each other.

What it stores: Actionable work items with status tracking, priorities, and completion notes linked to project documentation.

Formal task management with lifecycle tracking, linking related memories and documentation for complete context.

What it stores: Uploaded documents (PDFs, specs, manuals) with tech-specific chunking and encoding for intelligent search and retrieval.

Documents are automatically processed with semantic chunking and vector encoding, making them searchable alongside your memories.

What it discovers: Recurring approaches, design patterns, and architectural decisions across all your work.

Surfaces reusable solutions and consistent approaches that have proven effective across projects.

What it discovers: Recurring bugs, root causes, and successful fix approaches to prevent future issues.

Identifies patterns in bugs and their solutions, helping you avoid repeating the same mistakes.

What it discovers: Code smells, incomplete implementations, and areas needing refactoring based on your notes.

Highlights accumulated technical debt and suggests prioritization for refactoring efforts.

What it discovers: How your understanding evolves over time, showing knowledge growth and skill development.

Tracks your learning journey, showing how your approaches and solutions improve over time.

What it does: Find relevant memories using natural language queries. Results show summaries and key information-enough to decide what's relevant.

Start with high-level overviews before diving into details.

What it does: Get full details only for the specific memories you need. This saves time and keeps AI responses focused.

Drill down into complete context only when necessary.

What it does: Ask for insights to see patterns across all memories without reading each one individually.

Get meta-analysis and pattern recognition across your entire knowledge base.

What it does: Update or enhance memories as your understanding grows, keeping your knowledge base current.

Maintain an evolving knowledge system that improves over time.