Memory that survives the session: Hindsight extracts facts, entities, and timestamps from everything an AI agent retains, then lets the agent search or reason over it later. Adding it to an existing LLM client takes a two-line wrapper, and more than 60 integrations cover Claude Code, Cursor, LangGraph, CrewAI, and n8n. Every bank also exposes its own MCP endpoint. Retain sends text, images, or files through an LLM that extracts facts, timestamps, entities, and relationships. Recall runs semantic, keyword, graph, and temporal searches in parallel, merges them with reciprocal rank fusion, reranks with a cross-encoder, and trims to a token budget. Reflect reasons across memories for questions that need synthesis, shaped by per-bank skepticism, literalism, and empathy traits. In the background, related facts consolidate into observations that keep exact quotes and proof counts and are refined, never silently overwritten. Mental models and wiki-style knowledge pages hold standing answers that rewrite themselves as the bank learns. Each user, agent, or project gets an isolated bank with no cross-bank leakage, and Memory Defense redacts or blocks secrets and PII against 45 patterns. The Control Plane adds a Recall Analyzer with traces, a memory constellation graph, and a knowledge page editor. Extraction and reasoning can run on 25+ LLM providers, including local Ollama and llama.cpp. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. MIT licensed.

Statewave is the memory runtime that compiles what your AI agents experience into typed, provenance-tagged memories, so the same subject asked the same question receives the same context every time. Recording is append-only: your application writes events as episodes (chat, ticket, commit), and a compiler distills them into structured memories with confidence scores, each traceable to its source episodes. When an agent needs context, Statewave assembles a ranked bundle inside the token budget you set; the same request at the same moment returns identical bytes, so retrieval sampling noise never leaks into an answer. Every bundle leaves an HMAC-signed receipt that a replay endpoint can re-evaluate under the same rules. Memories carry sensitivity labels for personal data, financial details, and secrets, and YAML policies deny or redact them per tenant. One instance serves many products: tenants are isolated by header, pinned to a region for residency with cross-region requests refused, and erasable by subject on request. The default compiler runs fully local on regex heuristics with no API key, or point extraction at any of 100+ LiteLLM providers. Reach it over REST from any language, through typed Python and TypeScript SDKs, LangChain, CrewAI, and AutoGen integrations, or the built-in MCP server that lets Copilot, Claude, and Cursor share one memory. Support agents recognize returning customers across sessions, and coding agents keep project decisions between conversations. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache 2.0 licensed.

Cognee gives AI agents persistent long-term memory that survives across sessions, replacing the traditional stack of separate graph, vector, and session databases with a unified engine running on a single PostgreSQL instance. The memory-native API exposes four verbs (remember, recall, forget, and improve) enabling agents to persist context, retrieve cited answers, prune outdated knowledge, and self-improve from feedback. Under the hood, Cognee combines pgvector embeddings with a PostgreSQL-native graph store and cognitive-science-grounded ontology generation, delivering hybrid retrieval that fuses semantic similarity, structural graph traversal, and lexical search in a single query. Integrations span Claude Code, Cursor, LangGraph, OpenAI Agents, and any MCP-compatible client through a dedicated MCP server on port 8001, while the Python and TypeScript SDKs provide direct programmatic access. The platform supports swappable backends including Neo4j, FalkorDB, Qdrant, ChromaDB, Weaviate, Milvus, and LanceDB for teams with existing infrastructure. Built-in OpenTelemetry tracing, an experimental dashboard with knowledge graph visualization, multi-tenant user isolation, and audit trails ensure production readiness. Deploy via Docker Compose with optional profiles for PostgreSQL, Neo4j, Redis, and the web frontend. Reached v1.0 in April 2026 with 30,000+ stars. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache 2.0 licensed.

Memory OS gives Hermes Agent a permanent memory, so a new session opens with your projects, decisions, and working style already in context instead of introductions. Seven layers divide the job: workspace files carry your standing instructions into every turn, and a full-text index makes every past conversation searchable in place. Durable facts about your stack, your projects, and your patterns live in a structured store that resolves entities and scores how much each fact can be trusted, promoting what proves itself and demoting what does not. Cross-session recall pulls relevant moments from older threads, while a vector store with hybrid dense and keyword search finds the right memory even when the wording has changed. A self-curating wiki turns raw material into concept, entity, and comparison pages that are re-ingested automatically, and a Ground Truth hierarchy tells the agent to treat injected memories as authoritative instead of re-checking them. Scheduled jobs keep the system honest: hourly ingestion, weekly curation and decay scans, dead-letter reporting, and health heartbeats. It all runs beside the agent on your own machine with whichever provider you already use, from OpenRouter and Anthropic to a local Ollama. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. MIT licensed.

Memoh delivers an open-source multi-agent platform where every AI agent gets its own computer — not a chat window but a fully isolated container with dedicated filesystem, desktop environment, browser, network stack, and persistent long-term memory that survives across sessions, days, and platforms. The containerd-based runtime ensures each bot operates in complete isolation with snapshot and data import/export capabilities. The memory engine uses LLM-driven fact extraction with hybrid retrieval combining dense embeddings via Qdrant, sparse vectors, and BM25, plus 24-hour context loading and automatic compaction — with Mem0 and OpenViking as drop-in alternatives. Ten communication channels connect agents to users through Telegram, Discord, Lark, QQ, Matrix, WeCom, WeChat, Email, Web UI, and group chats with cross-platform identity binding. MCP tool calling enables agents to interact with external services, while browser automation drives GUI workflows for web research and data extraction. Agent hosting supports running external coding agents like Codex and Claude Code inside Memoh workspaces via ACP with per-bot configuration. Scheduled tasks run without human triggers, and agents proactively reach out when needed. The web dashboard built with Vue 3 and Tailwind CSS provides streaming chat, tool call visualization, file management, model and provider configuration, and bot lifecycle management. Deploy via Docker Compose with PostgreSQL, Qdrant, sparse service, and the Go backend server. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. AGPL-3.0 licensed.

TencentDB Agent Memory provides a team-level memory hub that transforms AI agent conversations, documents, and codebases into four governed, shareable memory assets: Chat Memory for conversation history, Skills extracted from completed tasks, LLM-Wiki built from document ingestion, and Code-Graph generated from codebase analysis. The four-tier semantic pyramid structures long-term memory from L0 raw conversation capture through L1 episodic extraction and L2 scenario aggregation to L3 persona synthesis, enabling hierarchical drill-down via node and result references instead of flat vector recall. The Node.js Gateway sidecar handles capture, extraction, storage, recall, and pipeline scheduling through RESTful HTTP v2 endpoints on port 8420, while the Memory Proxy intercepts Anthropic-format API calls to inject team memory context into Claude Code, CodeBuddy, and other coding agents transparently. Local SQLite with the sqlite-vec extension provides the default storage backend with hybrid BM25 keyword plus vector embedding plus reciprocal rank fusion retrieval requiring zero external API dependencies. Teams manage ownership, versions, status, visibility, usage counts, and agent bindings through the Memory Hub dashboard with role-based access control separating System Admin and team-level Admin and Member permissions. Official TypeScript and Python SDKs provide programmatic access for custom framework integration beyond the built-in OpenClaw plugin and Hermes Agent adapter. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. MIT licensed.

Engraphis is a durable memory layer for coding agents that answers questions like what did we decide about the auth layer three weeks ago, and why, with inspectable project memory that survives across sessions and repositories instead of evaporating when a chat ends. Store a decision once and recall it later in a new session, scoped by workspace, repository, and session so one project's facts never leak into another's context. Recall blends vector, lexical, graph, and code-aware retrieval, then packs the strongest evidence into a hard context budget your agent can actually use. Every returned fact keeps its provenance attached, and the engine cites its support or abstains when the evidence is too weak to trust. Facts are never silently overwritten: bi-temporal history preserves earlier versions, and a timeline view surfaces superseded knowledge when you need to know what used to be true. Index a repository into a code-symbol graph and ask what calls a function before you change it. Conflicting or quarantined memories wait in a review queue for a human decision. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache 2.0 licensed.

With over 24,000 GitHub stars and origins in the MemGPT research paper on virtual context management, Letta has evolved into the leading open-source platform for building AI agents that maintain persistent memory, identity, and continuity across sessions rather than operating as stateless prompt-response loops. The core architecture uses memory blocks — structured, labeled text chunks that reside permanently in the agent's context window — allowing agents to programmatically rewrite their own memory, learn new skills, and improve through a sleeptime dreaming process that runs reflection and memory organization during idle periods. The self-hosted App Server deploys via Docker and exposes a WebSocket API on port 4500, letting the TypeScript Agent SDK connect from any application using local, remote, or cloud backends. Agents support git-versioned memory through MemFS where every memory change is tracked and auditable, multi-agent communication via subagents, scheduled tasks, and integration with messaging platforms including Slack, Discord, Telegram, WhatsApp, and Signal. The platform is fully model-agnostic, routing to OpenAI, Anthropic, xAI, or self-hosted open-weight models through Ollama depending on cost, performance, and data residency requirements. The Agent File format serializes complete agent state — memory, skills, prompts, and conversation history — into portable snapshots. Desktop applications for macOS, Windows, and Linux provide native interfaces alongside the terminal CLI and web chat at chat.letta.com. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache-2.0 licensed.

Plain chunk retrieval hands an LLM disconnected excerpts; LightRAG builds a knowledge graph from your documents so answers can join facts spread across many files. Ask about one named person, product, or clause and local mode pulls its details. Ask for themes across the whole library and global mode follows the links between entities. Hybrid blends the two, naive falls back to plain chunk search, and mix combines all three. Mix is the default. Upload text, Markdown, PDF, Word, PowerPoint, and Excel files; MinerU, Docling, or the native parser can extract images, tables, and formulas. The admin console manages documents, explores the graph visually, and debugs queries, while a query-only workspace page gives everyday colleagues a clean chat screen that works on phones. A REST API covers indexing and queries, and an Ollama-compatible endpoint lets chat front ends such as Open WebUI use the knowledge base as a model. New files merge into the existing graph without a full reindex, and deleting a document rebuilds only the entities and relationships it touched from cached results. Separate model roles let an inexpensive model extract entities while a stronger one writes answers. An API key or accounts protect the server, and named workspaces keep several knowledge bases apart. Pair it with local Ollama models and no document text leaves the server. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. MIT licensed.

Cortex Hub gives every AI coding agent your team runs a shared brain, so what one agent learns in a repository is still there when the next agent, or the next person, opens it. Starting a session recalls the team knowledge and your own memory for that project, shows who else is editing, and picks up any task waiting for you. Agents search code by meaning and structure rather than text strings, tracing symbols, callers, and the blast radius of a change before touching it. Findings, file risks, and hard-won lessons are stored against the files they belong to, so they resurface exactly where they matter. Ending a session runs build, type, and lint checks, reports the result, and leaves a summary the next session starts from. A conductor can hand tasks to worker agents on other machines and track them centrally, while the dashboard shows sessions, keys, usage, and token savings across the team. Embeddings run locally by default, so your code memory never leaves the building just to be searchable. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. MIT licensed.

GitNexus turns any codebase into an interactive knowledge graph that maps every dependency, call chain, functional cluster, and execution flow, giving AI coding assistants the deep structural awareness they need to stop breaking things. Drop a repository URL or ZIP file into the browser-based explorer and watch Tree-sitter parsers decompose your code into a navigable property graph you can zoom, click, and query. The MCP server integrates directly with Cursor, Claude Code, Codex, Antigravity, and other editors through 16 specialized tools covering architectural queries, impact analysis, safe multi-file renames, change detection, and cross-repo contract matching. Need to know the blast radius before touching a shared utility? The impact analyzer traces every caller, implementer, and downstream consumer in milliseconds. Teams reviewing pull requests get automated blast-radius annotations powered by the same graph. The registry architecture lets a single MCP server manage multiple indexed repositories simultaneously, so switching between projects requires zero re-indexing. For visual exploration, the web interface renders interactive community-clustered graphs where you can trace execution paths, browse file trees, and chat with an AI agent grounded in the graph's structural data rather than raw file snippets. Everything runs locally; your source code never leaves the machine. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. PolyForm Noncommercial 1.0.0 licensed.

Navigating organizational knowledge, visualizing concept graphs, and orchestrating cooperative AI agents converge inside Yuxi, an open-source multi-tenant workspace built for enterprise research and deep archive exploration. Users can upload diverse business documents including scanned PDFs, spreadsheets, and slide presentations to automatically extract structured text blocks, tables, and entity relationships for semantic querying. Knowledge teams can inspect interactive topological graph views to explore connections between company entities, cross-referencing subgraphs against original file sources. Practitioners can configure autonomous agents with specialized subagents, assigning dedicated roles for concurrent research, deep data synthesis, and code execution. Human reviewers can inspect agent thought chains in real time and evaluate interactive confirmation cards before agents execute irreversible external actions or modify shared workspace files. Operators can execute sandboxed tasks that produce downloadable reports, interactive data charts, and rendered HTML pages stored within isolated workspace file systems. Administrators can govern model endpoints, set granular permission boundaries across departments, and monitor token consumption through live system analytics. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. MIT licensed.

With over 29,000 GitHub stars and deep integrations into LangChain, LlamaIndex, and CrewAI, Chroma has become the default vector database for developers building retrieval-augmented generation pipelines and AI agent memory systems. Its core API consists of just four functions — create, add, query, and delete — making it the fastest path from zero to semantic search, while the underlying Rust engine handles tokenization, embedding, HNSW indexing, and similarity scoring automatically. Chroma supports dense vector search via HNSW with configurable distance metrics including L2, cosine similarity, and inner product, sparse vector search using SPLADE, full-text BM25 keyword search, and regex matching, all combinable in hybrid queries through a single unified interface. Metadata filtering at query time uses MongoDB-style operators including $eq, $ne, $gt, $lt, $in, and logical combinators $and and $or, enabling precise result scoping without post-processing. The multimodal pipeline powered by OpenCLIP embeds text and images into a shared vector space, allowing cross-modal retrieval where text queries return relevant images and vice versa. Deployment options range from embedded mode via PersistentClient for notebooks and prototypes, to client-server mode with Docker for production, to Chroma Cloud for serverless scalability. Official Python and JavaScript SDKs provide identical APIs, and embedding function integrations support OpenAI, Cohere, Hugging Face, Google, Ollama, and custom models. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. Apache 2.0 licensed.

Some questions are really about how things connect, and Neo4j is the graph database that stores your data as nodes and relationships so those connections become the thing you query. Model people, products, accounts, devices, or transactions as labeled nodes with properties, then draw typed, directed relationships between them and traverse multi-hop paths in a single Cypher query instead of stacking SQL joins. The built-in Neo4j Browser renders query results as interactive node diagrams, so you can expand a fraud ring, a dependency chain, or a recommendation neighborhood visually and share the picture with your team. Cypher reads like the picture it queries: MATCH patterns describe shapes in the graph, filters narrow them, and aggregations roll up counts, sums, and shortest paths. Store embeddings as node properties and build vector indexes over them, then combine similarity search with graph traversal so matches can be filtered by owner, connections, or freshness. Full-text indexes search names, descriptions, and documents, while uniqueness constraints keep identifiers honest at write time. Bulk-load millions of nodes from CSV files with the offline import tool, then keep data flowing in through official drivers for Python, JavaScript, Java, Go, and .NET applications. Fraud teams trace shared phones and cards between accounts, platform teams map microservice dependencies before a migration, and security analysts hunt lateral movement through identity graphs. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. GPL-3.0 licensed.

FalkorDB is the first queryable property graph database to leverage sparse adjacency matrices and linear algebra for graph traversal, replacing traditional pointer-chasing with GraphBLAS-accelerated computation. Originally the RedisGraph engine, it was relaunched as FalkorDB in 2023 and rewritten from C to Rust in 2026 for improved memory safety and performance. The database supports the OpenCypher query language with proprietary extensions, translating queries into linear algebra expressions that exploit AVX hardware acceleration. Indexing options include full-text search, vector similarity for embedding-based retrieval, and range indexing, while connectivity supports both the RESP protocol for Redis clients and the Bolt protocol for Neo4j-compatible tooling. The GraphRAG SDK enables ingestion of documents in text, PDF, and Markdown formats into knowledge graphs, with schema-guided entity extraction, hybrid retrieval combining vector and graph traversal, relationship expansion, and cited answers for LLM applications. Official client libraries cover Python, Node.js, Java, Rust, Go, PHP, and C#. Multi-tenant support handles over 10,000 concurrent graphs with zero overhead and full isolation. Docker deployment runs the falkordb/falkordb image on ports 6379 for the database server and 3000 for the built-in browser UI, with persistent volume storage and optional authentication. A production falkordb-server image excludes the browser for lighter deployments. On RepoCloud, deploy FalkorDB on a dedicated VPS with root SSH access, persistent storage for your graph data, and complete control over authentication, thread count, and memory configuration, all under the SSPLv1 license.

OpenViking is a self-hosted context database that gives AI agents persistent, structured memory by organizing knowledge, skills, and session history into a hierarchical virtual filesystem accessible through the viking:// URI protocol. Instead of dumping everything into a flat vector store and hoping semantic search finds the right chunks, agents navigate their context with familiar commands like ls, tree, and find, locating exactly the information they need through deterministic paths combined with semantic search. Every resource is automatically processed into three layers: a 100-token L0 abstract for quick filtering, a 2,000-token L1 overview for content navigation, and the full L2 detail loaded only when confirmed necessary. This tiered approach cuts token consumption by 83 to 96 percent compared to conventional RAG while improving task completion rates by 15 to 49 percent on benchmark tests. The built-in memory self-iteration loop automatically analyzes task execution and user feedback, updating agent memory directories so the system continuously learns and improves. You can connect to any LLM provider, including Ollama for fully local inference, OpenAI, or compatible gateways. The Web Studio UI at the /studio endpoint provides visual browsing of the entire context filesystem, and the REST API on port 1933 supports programmatic access. Deploy via Docker, Kubernetes with the included Helm chart, or as a standalone service. Running on a dedicated VPS on RepoCloud with guaranteed CPU, RAM, and SSD, full root SSH access, and a browser serial console. AGPL-3.0 licensed.