MemoriLabs/Memori

Features

• Awesome List - A community-curated directory that catalogs and links out to other open-source projects, rather than a standalone tool you run yourself.
• Agent Memory Persistence - Maintains long-term state and continuity in AI assistant sessions.
• Agent Memory Stores - Persists durable facts and user preferences to ensure agents retain information across sessions.
• AI Memory Layers - Acts as a persistent storage layer that captures, structures, and retrieves conversation history and execution traces for AI agents.
• Context Injection - Intercepts outbound requests to dynamically inject relevant historical data into system prompts for improved model grounding.
• Contextual Retrieval - Performs semantic searches on outbound requests to inject relevant historical information into model prompts.
• Conversation History Management - Intercepts calls to automatically persist messages and responses into a database while supporting various execution patterns.
• Dual-Model Architectures - Maintains information as both structured relational primitives and rolling summaries for situational awareness.
• Agent Context Management - Restores agent working state and task progress across sessions by retrieving stored conversation history and execution traces.
• Agent Execution Tracing - Intercepts agent calls to automatically persist execution traces and conversation context across sessions.
• Persistent Agent Integrators - Connects agents to stateful models with long-term memory.
• Agent Context Management - Extracts and injects facts and preferences in the background to inform agent interactions without latency.
• Agent Memory Managers - Allows agents to share and recall information seamlessly across different models and services by scoping memory to specific entities.
• Context Management Tools - Automatically injects relevant historical facts and session summaries into model prompts to maintain continuity.
• Dual-Model Memory Architectures - Maintains information as both structured relational primitives and narrative summaries to support precise recall and situational awareness.
• Asynchronous Knowledge Extraction - Asynchronously extracts facts and constructs knowledge graphs to enhance contextual awareness.
• Contextual Memory Agents - Utilizes vector storage to maintain conversational history and schema context for improved query accuracy.
• Knowledge and Memory - Enables AI agents to store, retrieve, and manage long-term knowledge and context.
• Execution Knowledge Stores - Captures conversation history, tool activity, and decision outcomes into a structured, durable memory store.
• Agent State Persistence - Captures conversation history, agent traces, and coding decisions across sessions to maintain long-term state.
• AI Knowledge Bases - Processes raw dialogue into structured semantic triples and narrative summaries to create a searchable knowledge base.
• Hybrid Memory Stores - Retrieves past interactions, session summaries, and task briefs based on user queries or project context.
• Hybrid Search Engines - Combines vector-based similarity search with keyword matching to surface relevant historical facts for improved query accuracy.
• Knowledge Graph Builders - Extracts structured facts and semantic relationships from interaction data to build a queryable knowledge base for AI models.
• Persistent Conversation Stores - Captures and stores conversation history and execution traces automatically to ensure AI agents retain context across sessions.
• Persistent Context Managers - Extracts and stores conversation history and system instructions to maintain persistent memory across multiple sessions.
• Request Interception Middleware - Intercepts outbound model requests to automatically capture interaction history and inject context without modifying application logic.
• LLM Execution Tracing - Intercepts and stores model inputs and outputs automatically to maintain persistent conversation history.
• Memory Scoping - Links stored memories to specific users or processes to ensure information is properly indexed and retrieved.
• User Preference Management - Processes conversation history and user feedback to maintain persistent, long-term personalization profiles.
• Multi-Agent Coordination Systems - Enables multiple specialized AI agents to access and contribute to a unified knowledge space while tracking individual contributions.
• Memory Inspection Interfaces - Provides a centralized interface to view and manage historical execution traces and conversation data.
• Agentic Context Management - Assigns unique identifiers to individual agents to maintain separate conversation histories while accessing shared facts.
• Conversation History Trackers - Maintains the state of ongoing dialogues by automatically recording message history.
• AI Provider Integrations - Connects major language model services to automatically capture and recall conversation history.
• Multi-session Context Synthesizers - Connects related information across different conversations to answer complex questions.
• External Memory Integrations - Persists AI agent conversation history and execution traces within existing database infrastructure using standard integration patterns.
• Language Model Integrations - Connects to external language model providers to process inputs and generate responses with configurable parameters.
• Retrieval Augmented Generation - Captures interaction turns and execution context to enrich future memory retrieval and decision-making.
• LLM Provider Integrations - Wraps standard model calls to intercept interactions and manage memory injection without adding latency.
• Memory Persistence - Configures database connections to store and structure long-term memory using standard relational or document-based backends.
• Memory Reflection Automations - Automates the refinement and structuring of stored execution data to maintain efficient long-term memory.
• Prompt Engineering - Automatically injects relevant historical facts and situational summaries into model prompts to improve response accuracy.
• Interaction Capturers - Records conversation history and execution traces by registering clients and assigning attribution for future retrieval.
• Prompt Augmenters - Processes interaction data to extract knowledge for injection into future agent prompts.
• AI Agent Frameworks - Memory engine for LLMs and multi-agent systems.
• Execution Grounding - Integrates execution results and tool outputs with conversation history to ensure agents learn from past actions.
• Entity Attribution - Tags stored information with entity and process identifiers to ensure data isolation across workflows.
• Interaction History Caching - Stores user messages and assistant responses as durable memory to ensure continuity across future sessions.
• Vector Semantic Indices - Converts raw text into numerical vector representations to prepare information for semantic search and data recall.
• Search & Information Retrieval - Creates vector embeddings for stored information to facilitate fast semantic search and similarity-based matching.
• AI System Instructions - Maintains separate storage for system-level prompts to ensure consistent agent behavior across sessions.
• Memory Isolation - Creates distinct memory spaces for different users by attributing data to specific entity identifiers for secure context retrieval.
• Contextual Metadata Injection - Surfaces relevant memories using semantic search and intelligent ranking to inject background knowledge into system prompts.
• Execution History Structurers - Organizes conversation turns, tool activity, and workflow decisions into a persistent format.
• Agent Framework Integrations - Integrates with established agent frameworks to incorporate persistent memory capabilities into existing workflows.
• Model Provider Integrations - Wraps large language model services to enable persistent memory across diverse execution environments.
• Chat Model Integrations - Connects chat model implementations to persistent storage to enable long-term recall across sessions.
• Proactive Assistance Tools - Automatically retrieves relevant past information before generating responses to ensure consistent decision-making across tasks.
• Context-Aware Retrieval - Searches stored interaction history based on entity identifiers and similarity thresholds for context-aware operations.
• Conversational Session Management - Maintains context across multi-turn dialogues by tracking unique session identifiers.
• On-Demand Context Retrieval - Allows agents to explicitly query and summarize past execution data on demand to inform current decisions.
• Structured Collection Extraction - Parses unstructured input into an iterable collection of validated structured objects.
• Data Persistence and Storage - Stores and retrieves agent memory traces across a wide range of relational and document-oriented database systems.
• Interaction Structuring Engines - Converts raw conversation logs and execution traces into structured memory primitives.
• Database Connectivity - Integrates with various SQL and NoSQL database engines to store and retrieve persistent agent memory.
• Database Integrations - Provides configurations and drivers for connecting to various production-grade database systems.
• Graph Query Interfaces - Accesses stored semantic relationships directly via standard database queries to support debugging, analytics, and data exploration.
• Hybrid Vector-Graph Databases - Manages semantic embeddings and knowledge graph construction to provide long-term recall for language models.
• Session Attribution - Registers client sessions and assigns attribution metadata to ensure conversation history and agent traces are correctly associated.
• Persistent Storage Providers - Integrates with various SQL and NoSQL databases by accepting standard connection patterns to store and retrieve agent memory traces.
• Relevance Ranking Engines - Enables agents to explicitly query relevant historical context using multi-dimensional ranking to prioritize information.
• Semantic Mapping Tools - Identifies and stores subject-predicate-object triples to construct a knowledge graph that tracks entity associations.
• Session State Summarizers - Generates high-level overviews of past interactions to restore context and operational continuity.
• Vector Memory Stores - Provides a dedicated interface for inspecting stored agent memory, including captured messages and knowledge graph structures.
• Attribute Retrievals - Links stored information to specific users and processes to ensure data isolation and accurate retrieval.
• Multi-Tenant Isolation Layers - Enforces data separation between tenants in shared environments to ensure secure and context-specific retrieval.
• Asynchronous Background Processors - Offloads time-consuming operations to background threads or processes to maintain application responsiveness.
• User Attribution Systems - Links stored memories to specific user identities to ensure secure and scoped data retrieval.
• Agent Observability - Provides tools for monitoring memory performance and visualizing entity relationships to debug agent interactions.
• Token Usage Analytics - Reduces operational costs by injecting essential structured memory facts into prompts instead of verbose conversation logs.
• Agent State Summaries - Generates and manages high-level summaries of agent progress and state.
• Feedback Loops - Allows agents to report on the quality of retrieved information to refine future memory storage and improve recall accuracy.
• AI Agent Integration SDKs - Provides SDKs for connecting agents to persistent storage across synchronous and asynchronous environments.
• AI Agent Servers - Exposes integration schemas to connect agents to persistent storage via standard communication protocols.
• Asynchronous Model Execution - Supports non-blocking LLM requests to enable concurrent task processing and memory persistence.
• Chat Completion Services - Connects to chat completion endpoints using synchronous or asynchronous clients to facilitate agent communication.
• Cloud Model Integrations - Connects to managed cloud-hosted models to process agent requests using standard interface patterns.
• Relevance Feedback Systems - Submits user reports on the relevance and quality of recalled information to improve future extraction accuracy.
• Memory Retrieval Interfaces - Provides a programmatic interface to query stored information with relevance scoring for custom prompts and debugging.
• Model Response Aggregation - Aggregates streaming model responses for background processing and memory storage.
• Streaming Response Aggregators - Processes and captures incremental output from AI models in real-time.
• Temporal Evolution Trackers - Monitors changes in user status or situational context over time.
• Graph Visualizers - Displays extracted entities and their connections in a graph format to visualize relationships within agent memory.
• Asynchronous Storage Operations - Performs synchronous, asynchronous, or streaming memory retrieval and storage tasks to accommodate different performance requirements.
• Fact Deduplication - Updates mention counts and timestamps for recurring information to maintain a clean and prioritized knowledge base.
• Embedding Caches - Manages resource consumption by configuring embedding limits and offloading vector computations to maintain application responsiveness.
• Database Abstraction Layers - Provides a unified interface to connect with various relational and document-oriented storage backends for flexible data persistence.
• Storage Backend Configurators - Switches between managed cloud storage and self-hosted database solutions while maintaining a consistent interface.
• Summary Restorers - Provides structured summaries of active tasks and environment state to help agents resume work.
• Database Connection Configurations - Supports multiple connection patterns including sessions and direct drivers to manage database access for memory storage.
• Local Interaction Stores - Persists agent interaction history and execution traces in local file-based databases.
• Relational Database Connectors - Establishes persistent connections to relational databases to store and retrieve agent memory.
• Historical Search Filters - Refines memory search results using time ranges and keyword queries.
• Session Management - Groups related interactions into distinct sessions to maintain logical continuity and context for specific tasks.
• Unstructured Data Transformation Tools - Processes raw interaction logs into organized facts, vector embeddings, and knowledge graph triples.
• Fact Retrieval Systems - Retrieves individual pieces of information from past interactions to provide precise answers to direct user queries.
• Response Streaming - Supports streaming model outputs incrementally to provide real-time feedback during long-running interactions.
• Streaming Memory Handlers - Captures and persists data during streaming interactions to maintain long-term context.
• Process Memory Partitioners - Assigns unique process identifiers to different agents or tasks to maintain separate conversation histories.
• Asynchronous Request Execution - Executes non-blocking network requests to prevent application stalls during high-latency external service calls.
• Blocking Operation Handlers - Offloads storage and retrieval tasks to background threads to maintain application responsiveness during high-concurrency workloads.
• Relationship Graph Visualizers - Maps extracted entities and their connections into a graph interface to allow inspection of information relationships.
• Access Token Management - Generates and revokes authentication tokens to control programmatic access to organizational resources and services.
• Asynchronous Execution - Maintains memory consistency across both blocking and non-blocking agent calls.
• Agent Execution Tracing - Logs tool calls and decision outcomes to enable agents to learn from past actions across sessions.
• Recall Utility Evaluators - Enables agents to report the utility of retrieved information to refine future memory relevance and improve long-term performance.
• Adaptive Profiles - Constructs and updates long-term user profiles based on interaction patterns to personalize future AI responses.

Star history