rohitg00/agentmemory

Features

• Agent Memory Persistence - Provides a long-term knowledge store for AI coding agents to maintain continuity across project sessions.
• Agent Memory Server Runtimes - Runs the persistent knowledge store and manages the runtime engine that enables long-term agent memory.
• Agent Activity Observers - Automatically captures agent tool use and file operations through hooks to build a long-term knowledge store.
• Long-term Memory Stores - Implements a pipeline that compresses raw observations into long-term memory stores to reduce token costs.
• Fact Extraction Pipelines - Implements pipelines that process raw session data to isolate and store confirmed facts into long-term memory.
• Multi-Agent Coordination Systems - Manages task distribution across agents by tracking actionable work items, dependencies, and priorities.
• Agent Communication Protocols - Implements standardized protocols to connect AI agents to the persistent memory server for project data retrieval.
• Hybrid Search Retrievers - Combines keyword matching, vector embeddings, and graph traversal to retrieve the most relevant project context.
• Three-Tier Memory Architectures - Organizes raw observations into episodic, semantic, and procedural memory tiers to optimize token usage.
• Model Context Protocol Integrations - Provides standardized MCP tools that allow agents to explicitly save and analyze project patterns.
• Automated Activity Observation - Automatically records file edits and tool calls using lifecycle hooks to build a project knowledge base.
• Automatic Memory Extractors - Automatically extracts and records project details from agent activities without requiring manual user commands.
• Context Compression - Compresses observations and injects relevant context into the agent's prompt based on the available token budget.
• Knowledge Graph Extraction - Identifies entities and relationships within stored memories to enable context recall through graph traversal.
• Semantic Context Stores - Utilizes vector-based storage to manage compressed project state and retrieve context via semantic search.
• MCP Servers - Exposes memory capabilities as a standardized Model Context Protocol server for compatible AI agents.
• Memory Compression - Summarizes incoming observations into condensed memories using language models to minimize token usage.
• Memory Retrieval Budget Controllers - Limits the amount of recalled memory injected into prompts to optimize token consumption.
• Vector Embeddings - Generates vector representations of text using local or cloud providers to enable semantic retrieval.
• Memory Pattern Extraction - Analyzes stored memories to extract recurring cognitive patterns and project insights to update architectural context.
• Knowledge Graphs - Extracts entities and relationships into a graph structure to enable context recall through traversal.
• Agent Memory Stores - Functions as a persistent memory store that exposes project context to agents via a standardized server.
• Graph Traversal - Identifies related memories by traversing a graph of entities to surface connections between files and decisions.
• Hybrid Memory Stores - Implements a hybrid retrieval mechanism combining keywords and vectors specifically for AI agent memory.
• Vector Storage - Persists embeddings and indices locally on the machine to ensure data privacy and reduce API costs.
• Multi-Tier Memory Systems - Organizes agent experiences into episodic, semantic, and procedural tiers to optimize detail and token usage.
• Vector Databases - Provides a vector database for storing high-dimensional embeddings of project observations and facts.
• Activity Observation Recording - Records file operations, shell commands, and agent decisions to build a long-term history of observations.
• Vector Search - Retrieves historical observations based on conceptual similarity using embedding vectors and cosine similarity.
• Persistent Project Artifacts - Persists architectural decisions and naming conventions as managed artifacts to maintain project context across sessions.
• Team Memory Synchronization - Synchronizes a shared knowledge store across multiple users and agents using a team identifier.
• Shared Knowledge Graph Memory - Provides a shared knowledge graph where multiple agents can read and write common patterns with session-level isolation.
• LLM Context Window Injections - Automatically populates agent prompts with relevant historical context while respecting token budget constraints.
• RESTful Memory Administration APIs - Provides programmatic endpoints to save, recall, forget, or export memory entries and manage active sessions.
• Message-Passing Agent Orchestrators - Coordinates AI agents through a central hub where they exchange structured signals and messages in real time.
• Role and Context Isolation - Tags and filters memory by role to share knowledge or isolate data between different agents.
• Agent Monitoring - Monitors the lifecycle and interactions of sub-agents to capture distributed tasks.
• Model Provider Integrations - Integrates with cloud and local model providers to perform data compression and knowledge extraction.
• Action Approval Gates - Pauses agent task execution at specific checkpoints to request human approval before proceeding.
• File-Centric History Retrieval - Collects all recorded edits and decisions associated with a specific file from earlier sessions.
• Local AI Runtimes - Runs memory servers and embedding models on local hardware to ensure data privacy.
• Offline Model Runners - Enables fully offline operation using local embedding and model servers to ensure data privacy.
• Multi-Agent Coordination - Synchronizes a shared memory pool and task dependencies across multiple autonomous agents.
• Pinned Context Slots - Provides dedicated, editable slots for persisting personas and guidelines that agents can reference.
• Embedded Storage Engines - Utilizes a local embedded storage engine to keep observations and indices on the local machine for privacy.
• Execution Collision Preventers - Uses locking mechanisms to prevent multiple agents from executing the same task simultaneously.
• Keyword Search - Implements text-based search using term frequency and synonym expansion to match exact technical terms.
• Search Result Fusion Algorithms - Combines and re-ranks results from multiple search methods to provide diversified and relevant context.
• Task Dependency Filters - Retrieves high-priority tasks by filtering for those whose dependencies have been met.
• Agent Execution Replays - Visualizes a timeline of prompts and tool calls with playback controls to audit agent activities.
• AI Skills - Persistent memory solutions for coding agents.

Star history