Memoh is an open-source, full-stack AI agent platform that provides each agent with an isolated cloud computer (filesystem, desktop, browser, network, long-term memory). The system is built around a Go backend with Echo HTTP and gRPC, Vue 3 frontend with Pinia, and an Electron desktop shell. It supports multiple agent runtimes (native, ACP, Codex, Claude Code), a wide range of messaging channels (Telegram, Discord, Feishu, WeChat, LINE, DingTalk, etc.), and container-based workspaces via containerd or Docker. The architecture is a monolith with clearly separated packages for channel adapters, context management, session orchestration, and tool execution. The codebase demonstrates high engineering craftsmanship with extensive test coverage, sophisticated concurrency patterns (runtime fences, decision waiters, atomic compaction barriers), and a modular context fragment system for prompt assembly. It is actively maintained with frequent commits, thorough CI/CD, and over 140 database migrations.
This repository implements a persistent memory server for AI agents, designed to solve the problem of agent amnesia across sessions, devices, and team members. The production system is a Rust-based HTTP server (Axum) that exposes a RESTful API with 48+ endpoints, backed by LanceDB for vector storage and supporting both hosted and self-hosted deployments. It ingests conversational or document data via an LLM-powered pipeline that extracts atomic facts, filters noise, scores admission, and reconciles with existing memories using seven operations (CREATE, MERGE, SUPERSEDE, etc.). The system manages a full memory lifecycle with Weibull decay, tier-based promotion/demotion, and auto-forgetting, and provides a multi-stage retrieval pipeline that combines vector search, BM25, cross-encoder reranking, decay boosting, and MMR diversity. Plugins for Claude Code, OpenCode, OpenClaw, and MCP allow client-side integration, and a GitHub connector ingests commits, issues, and PRs as memories. The architecture is multi-tenant with personal, team, and organization spaces, each isolated in separate LanceDB directories, and supports versioned, provenance-tracked sharing with staleness detection.
claude-mem is a persistent memory system for AI coding assistants, primarily targeting Claude Code but also supporting Codex, Cursor, Windsurf, OpenClaw, and other platforms. It captures observations, summaries, and user prompts from coding sessions via lifecycle hooks (SessionStart, PostToolUse, etc.), stores them in SQLite (local) or Postgres (server), and injects relevant context into future sessions to maintain continuity across agent interactions. The system operates as a background worker daemon (Bun) or a multi-user server (Express + BullMQ + Valkey) with API key authentication, team/project scoping, and rate limiting. Architecturally, claude-mem is a hybrid of a CLI plugin and a standalone server. The CLI component integrates into IDEs via hook scripts and MCP servers, while the server component provides REST APIs for memory management, search, and cloud sync. It features a dual-storage backend (SQLite for local, Postgres for server) with vector search via ChromaDB and full-text search via SQLite FTS5. The system includes a React-based viewer for browsing memory feeds, telemetry (opt-out PostHog), and a Cloudflare Workers-based sync hub for cross-device synchronization. The codebase demonstrates strong engineering practices with well-abstracted components (search strategies, provider abstraction, atomic file operations, telemetry scrubbing) but carries some technical debt from its dual-runtime evolution (legacy worker vs. server-beta) and extensive Windows-specific workarounds. It is actively maintained with frequent releases and comprehensive test coverage.
Kronotop is a distributed database system built on FoundationDB that provides Redis-compatible (RESP2/RESP3) interfaces for multiple data models including key-value (stash), document (bucket with BSON storage and querying), and sorted sets (zmap). It features ACID transactions, secondary indexing (including vector search via HNSW), clustering, sharding, replication, and namespace isolation for multi-tenancy. The architecture is modular with clear separation between network handling (Netty), protocol processing, service layers (transaction, session, data services), and storage (volume-based segment store). Key entry points include the server entry point (KronotopInstanceStarter), CLI (kronotop-cli), and control tool (kronotop-ctl). The system relies on external dependencies such as FoundationDB, Netty, Jackson, Lettuce, Guava, JVector, and Typesafe Config. The codebase demonstrates strong engineering practices with reusable components like versionstamp utilities, retry mechanisms, and protocol handling.
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.
MemoryBear is a production-oriented, multi-tenant AI agent platform whose core differentiator is a cognitive-inspired persistent memory system for LLM applications. The code — not the README — shows a full SaaS stack: a FastAPI backend (~60 domain controllers), a React/TypeScript admin console, an identity/auth service, an API gateway, a dedicated RAG knowledge service, and a Rust seccomp sandbox for code execution. The memory subsystem is the heart: pipelines extract statements, triplets, entities, emotions, preferences, and implicit habits from conversations into a Neo4j knowledge graph (projected to Elasticsearch through a transactional outbox), with ACT-R-inspired forgetting/reinforcement scheduling, LLM reflection/dedup, BERT scene-boundary detection, and hybrid retrieval at query time. This is an application, not a data-research repo, although the memory-science algorithms (forgetting curves, emotion classification, value ranking) are shipped as product features rather than research artifacts.
Graphiti is a Python library and server framework for building temporal knowledge graphs that serve as persistent memory for AI agents. It ingests unstructured text episodes (messages, transcripts, JSON), uses LLMs to extract entities and relationships with bi-temporal validity windows, deduplicates against existing graph data, and provides hybrid search (semantic + BM25 + graph traversal) with configurable reranking. The codebase is structured around a clean driver abstraction (Neo4j, FalkorDB, Kuzu, Neptune) with per-provider operations classes, a prompt library supporting versioning and overrides, and a multi-provider LLM/embedder/cross-encoder client system. It is primarily an application library, though it includes evaluation infrastructure and research-grade deduplication algorithms (MinHash/LSH).
VeritasGraph is a comprehensive, governed GraphRAG and agent framework for building enterprise-grade knowledge graphs with verifiable attribution. The repository contains a core Python library (VeritasReason) for knowledge graph construction, semantic extraction, reasoning, provenance tracking, and export, along with multiple domain-specific applications: a HIPAA-safe clinical knowledge graph pipeline (clinical-kg), a floorplan extraction and validation web app (floorplan-kg), a municipality incident reporting chatbot, and a Model Context Protocol (MCP) server for IDE integration. The architecture is modular, with a plugin-based method registry pattern, unified configuration management, and a pipeline orchestration engine. While the primary character is an application framework, it also includes research-oriented components such as clinical benchmarks (MedKG-Signal) and evaluation suites, making it a hybrid project with a strong application focus.
LeanKG is a Go-based knowledge graph engine for AI-assisted development. It indexes source code from multi-language repositories into a graph of elements (functions, types, classes) and relationships (calls, imports, implements), stored in SQLite or PostgreSQL with optional vector embeddings for semantic search. The system provides a CLI, REST API, MCP (Model Context Protocol) server, and a React web UI (force-directed graph, file tree, code panel). Core capabilities include incremental indexing with three-signal change detection, a four-tier query ladder (cold/exact/fuzzy/semantic), impact analysis with blast radius, organizational knowledge management (incidents, notes, env reports), ontology matching, federation across servers, and token-budgeted compression for AI tool integration. The architecture is modular: the store backend interface supports SQLite and PostgreSQL with a shared migration ledger; indexing uses regex extractors for 40+ languages with an optional tree-sitter CGO tier; embeddings use a provider abstraction (OpenAI-compatible, llama.cpp sidecar, deterministic). The codebase is well-structured with extensive tests, hermetic test patterns, and deterministic output design. Notable reusability includes the compress package (shell output, git diff), auth token system, store abstraction pattern, and A/B benchmarking harness.
Supermemory is a commercial-grade AI memory and context engine that provides persistent long-term memory for AI agents. The repository implements the client-side integration SDKs, an MCP (Model Context Protocol) server, a memory graph visualization component, and supporting infrastructure. In production, it connects to an external cloud API (api.supermemory.ai) that handles document ingestion, semantic search, user profiles, and knowledge graph construction. The codebase is organized as a monorepo with distinct packages for TypeScript/Python SDKs covering multiple AI frameworks (Vercel AI SDK, OpenAI, Mastra, Claude, etc.), a Cloudflare Workers-based MCP server with OAuth and widget UI, a ship-grade memory-graph React component with force-directed canvas rendering, and a comprehensive validation schema package. The architecture demonstrates strong engineering practices: strict Zod validation, middleware injection patterns, caching and deduplication logic, and thorough testing across languages. Notable skill is evident in the memory-graph canvas engine (viewport, simulation, spatial indexing, version chain visualization) and the shared memory-context injection utilities. The main downside is significant logic duplication across four Python SDK packages and their TypeScript counterparts, which increases maintenance risk. The repo is actively developed with CI/CD pipelines publishing to npm and PyPI.