Integrate Agent Memory: https://github.com/rohitg00/agentmemory with Klaatcode

[shivaylamba]

Feature: Integrate agentmemory for persistent cross-session memory

Description

It would be useful to integrate agentmemory with KlaatCode to provide persistent memory across coding sessions.

agentmemory is an open-source persistent memory layer for AI coding agents:

Repository: rohitg00/agentmemory

It allows coding agents to capture useful information from previous sessions, retrieve relevant memories later, and maintain context across otherwise independent conversations.

Motivation

KlaatCode already provides strong project understanding through its code knowledge graph and context-management capabilities. However, there is an opportunity to complement this with persistent memory across sessions.

For example, a developer might use KlaatCode to:

1. Design an authentication architecture in one session.
2. Make implementation decisions and fix several issues.
3. Close KlaatCode.
4. Return to the project several days later.

With agentmemory integrated, KlaatCode could recall relevant information such as:

• architectural decisions made in previous sessions
• debugging discoveries and previous fixes
• project-specific conventions
• developer preferences
• important implementation context
• previous approaches that failed and why
• task/session history relevant to the current request

This could reduce the need for users to repeatedly explain project context when starting new KlaatCode sessions.

Proposed Integration

agentmemory already exposes both an MCP server and a REST API, so there are a few possible levels of integration.

Option 1 — MCP integration

Allow users to configure agentmemory as an MCP server and expose its memory tools to the KlaatCode agent.

Example workflow:

User prompt
    ↓
KlaatCode
    ↓
Search relevant memories through agentmemory
    ↓
Combine recalled context with KlaatCode's code knowledge graph
    ↓
Model reasoning / tool execution
    ↓
Store useful observations back into agentmemory

This would likely be the simplest first integration.

Option 2 — Native lifecycle integration

For a deeper integration, KlaatCode could automatically interact with agentmemory during important lifecycle events.

For example:

Session Start
    → retrieve relevant project/session memories

User Prompt
    → search for memories relevant to the current task

Tool / Agent Actions
    → capture useful observations

Task Completion
    → persist important decisions and discoveries

Session End / Compaction
    → store a concise session summary

This would make persistent memory largely transparent to the user.

Relationship with KlaatCode's Existing Context System

The intention would not be to replace KlaatCode's existing context management or code knowledge graph.

Instead, the two systems could complement each other:

KlaatCode Knowledge Graph
        ↓
Current repository structure
Symbols / callers / callees
Code relationships
Current implementation context

agentmemory
        ↓
Cross-session knowledge
Past decisions
Developer preferences
Previous debugging discoveries
Historical task context

Together this could provide both repository intelligence and long-term agent memory.

Configuration

Ideally the integration could remain optional, for example:

{
  "memory": {
    "provider": "agentmemory",
    "url": "http://localhost:3111"
  }
}

Users who don't need persistent memory could continue using KlaatCode exactly as they do today.

Acceptance Criteria

• KlaatCode can connect to a running agentmemory instance.
• Relevant memories can be searched/recalled during a KlaatCode session.
• KlaatCode can persist useful observations or session information.
• Memories are scoped appropriately to avoid unrelated project context leaking between repositories.
• The integration can be enabled/disabled through configuration.
• KlaatCode continues to work normally when agentmemory is unavailable or disabled.
• Documentation includes setup and configuration instructions.

Additional Context

agentmemory already supports coding agents through MCP, HTTP APIs, hooks, and agent-specific integrations, so KlaatCode seems like a natural additional integration target.

A first iteration could focus purely on MCP/REST connectivity, with deeper lifecycle hooks and automatic context injection added later if useful.

[shivaylamba]

@rohitg00