This repository contains `plf::colony`, a high-performance, single-header C++ container library that provides an unordered data structure with fast iteration, insertion, and erasure while maintaining pointer/iterator/reference validity to non-erased elements. It is implemented as a template class in `plf_colony.h`, supported by `plf_tools.h` which provides compiler feature detection macros, utility functions, and allocator-aware helpers. The container uses a novel skipfield-based memory management technique (low-complexity jump-counting pattern) to achieve O(1) amortized insertion and erasure, and O(n) iteration with minimal overhead. It supports C++98 through C++23, with extensive compile-time feature detection and conditional compilation. The codebase is exceptionally well-crafted, demonstrating advanced template metaprogramming, low-level memory optimization, and careful handling of allocator traits, exception safety, and trivial type optimizations. The test suite (`plf_colony_test_suite.cpp`) is comprehensive, covering correctness, edge cases, fuzz testing, and exception recovery. The repository is a standalone library intended for reuse in any C++ project requiring a flexible, high-performance container with stable iterators.
Mem0 is a production-grade memory layer for AI agents, providing persistent, searchable, and updatable memory across sessions. It operates as both an open-source Python/TypeScript SDK and a hosted platform (api.mem0.ai). The core library abstracts away LLM providers (OpenAI, Anthropic, Groq, vLLM, etc.), embedding models, vector stores (over 20 backends including Qdrant, Pinecone, PGVector, Chroma, Weaviate, and many more), and rerankers behind a consistent config-driven interface. Memory operations (add, search, update, delete) support scoping by user, agent, session, or run, and leverage hybrid search combining semantic, BM25, and entity-boost signals with configurable reranking. The repository is architected as a monorepo with a clear separation of concerns: the core SDK packages (`mem0/` for Python, `mem0-ts/` for TypeScript), a self-hosted FastAPI server with a Next.js dashboard, CLI tools in both Python and Node.js, and a comprehensive plugin ecosystem for AI coding agents (Claude Code, Cursor, Codex, Kimi, Antigravity, Pi Agent, OpenClaw, etc.). Each integration follows a uniform hook adapter pattern, translating native agent events into memory operations via MCP servers or shared core modules. The platform backend includes authentication, API key management, telemetry via PostHog, and a webhook system for event-driven workflows. Key data flows: An application calls `memory.add()` with messages and metadata → the SDK extracts facts via an LLM → embeds them using the configured embedder → stores vectors and metadata in the chosen vector store. On `memory.search()`, the query is embedded, hybrid-scored against stored vectors (with optional reranking), and results are returned with relevance scores. The system supports temporal reasoning (timestamp filtering, memory decay), entity-based partitioning, custom categories, and feedback mechanisms to refine future retrievals. External dependencies include LLM APIs, vector databases, embedding services, and optionally Redis/SQLite for local history.
EverOS is a local-first, markdown-based memory framework for AI agents and chat applications. It ingests conversational sessions via a FastAPI REST API, extracts structured memories (episodes, atomic facts, agent cases, skills, user profiles) using LLMs, persists them as version-controllable Markdown files, and maintains derived search indexes in LanceDB (vector + BM25) and SQLite. The system provides a rich retrieval layer with keyword, vector, hybrid (RRF), and agentic (LLM-guided multi-round) search methods, plus a knowledge wiki feature. An Offline Memory Engine (OME) runs background strategies (reflection, clustering, extraction) on cron/idle/immediate triggers, and a cascade daemon watches the Markdown filesystem to reconcile indexes. The architecture is a layered monolith (entrypoints → service → memory → infrastructure) with cross-cutting components for LLM, embedding, rerank, tokenizer, and config. It ships with a CLI (Typer), a TUI demo (Textual), and extensive integration tests. While primarily an application, it includes a benchmark harness (LoCoMo, LongMemEval, EverMemBench) and evaluation fixtures, giving it a hybrid character with a strong research-oriented testing pipeline.
DeerFlow is an open-source, full-stack AI agent harness built on LangGraph/LangChain, providing a production-ready platform for building, deploying, and managing conversational AI agents. The system features a Python/FastAPI backend with a modular architecture that includes agent orchestration, long-term memory (DeerMem), sandboxed code execution, a skill system with static analysis (SkillScan), MCP (Model Context Protocol) tool integration, multi-channel IM support (Telegram, Slack, Discord, Lark, etc.), scheduled tasks, subagent batches, and a comprehensive authorization framework. The frontend is a Next.js/React workspace with real-time streaming, artifact management, and a terminal UI (TUI) for headless operation. The architecture follows a gateway pattern: the FastAPI gateway handles authentication (JWT, OAuth, PATs), routing, and SSE streaming, while the core harness package (`deerflow`) implements agent logic, middleware chains, and runtime components. Persistence uses SQLAlchemy with Alembic migrations, supporting both SQLite and PostgreSQL. The system is highly extensible via a Python extension API (`deerflow-extension-api`) and a plugin system for frontend surfaces. Deployment supports Docker Compose and Kubernetes (Helm chart). While primarily an application, DeerFlow includes research-oriented components such as memory eviction benchmarks, context snapshot evaluations, and tracing integrations (LangSmith, Langfuse, OpenTelemetry). The codebase demonstrates strong engineering practices with extensive unit tests, blocking IO regression tests, and contract tests, though its large feature surface and many configuration options introduce complexity and potential for drift between environments.
MMTk (Memory Management Toolkit) is a high-performance, portable garbage collection framework written in Rust. It provides a library of reusable GC algorithms (plans) including generational, concurrent, mark-sweep, immix, reference-counting (LXR), and mark-compact variants. The system exposes a trait-based VM binding interface (VMBinding) that language runtimes implement to integrate MMTk as their garbage collector. The architecture is modular: a parallel work-stealing scheduler dispatches GC work packets, policy spaces encapsulate memory allocation strategies (bump, free-list, immix, large object, etc.), and a flexible metadata system supports both header-resident and side metadata. The crate is not a standalone application; it is consumed as an rlib by VM bindings such as OpenJDK, JikesRVM, V8, Julia, and Ruby. Extensive use of procedural macros (HasSpaces, PlanTraceObject) reduces boilerplate for adding new GC plans. The codebase includes performance tracing tools (eBPF, Perfetto) and a comprehensive test suite with mock VM support.
CowAgent is a production-grade multi-agent AI assistant platform that routes messages from 12+ IM channels (WeChat, Feishu, Telegram, DingTalk, Slack, Discord, QQ, WeCom, web console, desktop Electron app) through a modular agent core. The core implements planning, tool use (bash, file editing, browser, web search, MCP, sub-agent delegation, scheduler, memory, vision), three-tier memory with vector embeddings and markdown-aware chunking, knowledge base management, skill system with SKILL.md manifests and a skill hub, self-evolution (idle-conversation review loop), and multi-agent team orchestration with peer transport. The architecture is a modular monolith: channel adapters normalize messages into a unified ChatMessage, the Bridge dispatches to per-agent/session model resolution, the Agent protocol (Task/AgentResult/AgentAction) drives the execution loop with streaming, cancellation, and steering, and all state persists to SQLite with incremental migration. Key entry points are app.py (startup orchestration), cli/cli.py (daemon lifecycle), channel/web/web_channel.py (HTTP API and SSE streaming), and the desktop Electron client (React/TypeScript with Zustand stores). External dependencies include LLM APIs (OpenAI, Claude, Gemini, DeepSeek, etc.), IM platform webhooks/SDKs, optional voice TTS/ASR providers, and MCP servers. The codebase demonstrates strong engineering practices with extensive regression tests (200+ test files), atomic file writes, thread-safe context propagation via ContextVar, and security guards for credential paths and SSRF.
This repository implements a system to use NVIDIA GPU VRAM as swap space on Linux via the NBD (Network Block Device) protocol. The core component is a userspace daemon (nbd-vram) that allocates VRAM using the CUDA driver API and serves it as a block device over a Unix socket. The Linux kernel's NBD driver connects to this socket, exposing /dev/nbdX as a swap device. The system includes scripts for connection/disconnection, power management (automatically disabling swap on battery), and proper handling of suspend/resume to avoid GPU-related deadlocks. Key features include memory locking to prevent the daemon from being swapped out, using PR_SET_IO_FLUSHER to avoid deadlocks under memory pressure, and multi-threaded request batching to amortize CUDA synchronization overhead. The solution works with any CUDA-capable NVIDIA GPU without requiring kernel modifications or NVIDIA's P2P API, which is restricted to professional GPUs.
Cognee is an open-source AI memory platform that enables agents and applications to build, store, and query persistent knowledge graphs from documents, code, and conversations. The system provides a Python SDK, a FastAPI REST API, a CLI, a Next.js frontend, and an MCP server for agent integration. Core operations include ingesting data (remember), extracting entities and relationships via LLMs or GLiNER (cognify), retrieving context (recall), and self-improvement loops (improve). The architecture is modular with adapter/registry patterns for graph databases (Ladybug, Neo4j, Turso), vector stores (LanceDB, PGVector), LLM providers (LiteLLM, OpenAI, Anthropic, Ollama), and integrations (Slack, GitHub, Google Drive). The frontend provides a dashboard for dataset management, knowledge graph visualization, and business analytics. The project also includes an evaluation framework for benchmarking retrieval strategies against standard datasets like HotpotQA and BEAM. While production-grade in many areas, some components are marked as demo-quality or have cloud-only stubs.
Zep is a long-term memory platform for AI agents, providing integration libraries for multiple agent frameworks (Google ADK, AutoGen, CrewAI, LangGraph, Pydantic AI, Vercel AI SDK, Mastra, LiveKit, Microsoft Agent Framework, Strands, AG2) across Python, TypeScript, and Go. The repository contains the core ingestion pipeline (zep-ingest) for bulk loading documents, Slack exports, emails, transcripts, and fact triples into Zep's temporal knowledge graph, an MCP server for direct graph access, benchmarks (LoCoMo, LongMemEval), and extensive examples. The architecture is a set of client libraries that communicate with the Zep Cloud API (external dependency). Key entry points include integration packages (e.g., zep_adk, zep_autogen), the ingestion pipeline (Pipeline, ingest functions), and the MCP server (cmd/server/main.go). Data flows: user messages are persisted to the Zep graph, context is retrieved and injected into agent prompts via hooks/callbacks or search tools. External dependencies: Zep Cloud API, optional LLM clients (OpenAI, Anthropic) for ingestion transforms and contextualization.
CyberClaw is an enterprise-grade transparent AI agent architecture that implements a dual-watermark memory system, full behavior auditing, zero-trust execution via two-phase skill invocation, and a heartbeat task engine for scheduled operations. The system provides an interactive conversational interface where users can query time, perform calculations, manage files, execute shell commands within a secure sandbox, and utilize pluggable skills. All agent actions are transparently logged to JSONL files for monitoring and compliance. The architecture features clean separation of concerns with distinct modules for agent logic, skill loading, context management, logging, heartbeat tasks, and tool execution.
MemReduct is a Windows desktop application for real-time memory monitoring and cleaning, implemented in C with the Win32 API and the undocumented Native API. It operates as a system tray utility that can manually or automatically purge various Windows memory caches: working sets, standby list, modified page list, system file cache, registry cache (Win8.1+), and combined memory lists (Win10+). The core cleaning logic uses NtSetSystemInformation with specific information classes, supplemented by volume cache flushing via the MOUNTMGR device. The application requires administrator privileges for full functionality and provides a configuration GUI with settings for auto-clean thresholds, intervals, hotkeys, language selection, and tray icon appearance. The architecture is monolithic: a single executable built from source files (main.c, main.h, resource files) that links against a reusable utility library (the 'routine' submodule). This library abstracts common Win32 tasks such as registry/INI config management, localization via .ini files, custom listview controls, theme handling, and device context operations. The application entry point is wWinMain in main.c, which creates the main dialog and processes window messages via DlgProc. Memory status is polled every second via a timer callback, and cleaning actions are triggered either manually through the UI or automatically based on user-defined thresholds. External dependencies are limited to Windows system DLLs (kernel32, user32, ntdll, advapi32) and the two submodules: 'routine' (utility code) and 'builder' (installer packaging). The build system uses Visual Studio 2017 project files with batch scripts for x86, x64, and ARM64 targets. No network dependencies exist except an optional update check. The codebase demonstrates non-obvious skill in low-level Windows system programming, custom GDI tray icon rendering, and conditional feature compilation, but remains maintainable through its separation of concerns in the routine library.
This repository implements a Field-Programmable Gate Array (FPGA) based emulator for Nintendo Game Boy and Game Boy Color systems, specifically targeting the Analogue Pocket handheld console. The design consists of hardware description language (Verilog/VHDL) modules that replicate the original hardware components including a Z80-compatible CPU core (T80), memory controllers, video display subsystem, four-channel audio processing unit, input handling, cartridge interface with various Memory Bank Controller (MBC) implementations, save state functionality, and real-time clock support. The architecture follows a modular approach with clear separation of concerns between subsystems, interconnected through well-defined interfaces. The project demonstrates significant effort in achieving hardware-level accuracy while incorporating modern features like save states, fast forwarding, and custom palettes. While the codebase shows signs of active maintenance and ongoing development, it remains tightly coupled to the target FPGA platform (Cyclone V) and associated Intel/Altera toolchain, which limits immediate portability to other hardware platforms.
This repository is an 'awesome list' curated by the TeleAI-UAGI team, aggregating open-source and closed-source products, papers, benchmarks, tutorials, and surveys on memory systems for LLM/MLLM agents. It does not contain application business logic or runnable services; its primary output is a meticulously structured README.md that serves as a reference catalog. The accompanying Python scripts automate two maintenance tasks: (1) checking that open-source entries are ordered by GitHub star count and respecting a 100-star boundary for emerging projects, and (2) generating self-hosted star-history SVG charts. The scripts are well-crafted, with robust parsing, GitHub API integration, and careful edge-case handling (grace bands, orphan detection), making them reusable for other awesome-list maintainers. The repository's value lies in its curated content rather than its code, but the supporting infrastructure demonstrates solid engineering principles.