GBrain is a personal knowledge management system designed as an AI agent memory layer. It provides a persistent knowledge base that runs as a 24/7 daemon for continuous ingestion, enrichment, and consolidation of information from various sources. The system features a CLI-first architecture with MCP (Model Context Protocol) support for AI agent integration, a web admin interface, and extensibility through skill packs. It uses a hybrid storage approach with PGLite for local/single-user deployments and Postgres+pgvector for shared/scale deployments, incorporating vector search, full-text search, and a self-wiring knowledge graph with typed edges. The system includes evaluation frameworks (BrainBench, takes-quality assessment), an advisor system for health recommendations, and automated maintenance cycles.
AFFiNE is a cross-platform, block-based knowledge management application that combines notes, whiteboards, and databases in a local-first, real-time collaborative environment. Built on the BlockSuite editor framework, it features a modular architecture with extensible components, AI-powered capabilities (Copilot), and support for embedding external content. The application consists of a web client, desktop client (Electron), and mobile clients (iOS/Android), backed by a Node.js/NestJS server with Prisma ORM and Rust performance modules. Data is synchronized via Yjs CRDTs with a custom storage layer (nbstore) for offline-first capabilities.
This repository is a local-first, source-cited knowledge base management system, delivered primarily as a Claude Code plugin and a standalone Python CLI tool. It manages Obsidian vaults with a strong emphasis on data integrity, provenance tracking, and deterministic operations. The architecture is a monolithic Python library (`claude_obsidian/`) with a formal transaction system for all vault mutations, a robust lint engine, and a retrieval pipeline (BM25 + optional semantic reranking). It features a sophisticated skill/agent framework for AI integration across multiple hosts (Claude, Cursor, Windsurf, etc.). While primarily an application, it incorporates significant data engineering and research data management (RDM) patterns. The provenance ledger system (`ledgers.py`) enforces strict schemas for sources and claims, including canonical URL handling, content-addressed identity, and evidence validation rules. The retrieval pipeline implements Anthropic's Contextual Retrieval pattern. This hybrid nature makes it a powerful tool for both knowledge management and structured research workflows. The codebase demonstrates exceptionally high craftsmanship in its transaction system, defensive I/O, and deterministic analysis tools. It is actively maintained with a comprehensive test suite and a formal release process. Its primary limitation is platform dependency on Linux/macOS for write operations (WSL required for Windows).
Project NOMAD is an offline-first personal server platform that turns a single machine (Debian-based) into a self-contained knowledge and AI appliance. It orchestrates Docker containers for services like Kiwix (offline Wikipedia/books), Ollama (local LLMs), Qdrant (vector database for RAG), and many other curated apps (Calibre-Web, Jellyfin, Vaultwarden, etc.) via a Node.js/TypeScript backend (AdonisJS) with a React frontend (Inertia.js). The system manages content downloads (ZIM files, maps, FDA drug labels), provides an AI chat assistant with RAG (Retrieval Augmented Generation), offers hardware benchmarking (NOMAD Score), and includes a full auto-update mechanism for core, apps, and content. Key entry points include the installation script (`install_nomad.sh`), the HTTP server (`admin/bin/server.ts`), and an extensive REST API defined in `admin/start/routes.ts`. Background processing is handled by BullMQ job queues (downloads, embeddings, drug data ingestion, benchmarks). External dependencies include MySQL, Redis, Docker (DooD), Ollama, Qdrant, and openFDA for drug labels. The platform is designed for privacy (no telemetry) and resilience (offline operation, content caching, health-gated rollbacks).
AnyType is a personal knowledge base application built with Electron, React, and TypeScript. It features a block-based system for creating and connecting information (text, databases, kanban, calendar, custom types) with offline-first storage and optional peer-to-peer synchronization. The application uses a modular architecture with a Go-based middleware (anytype-heart) communicating via gRPC, MobX for state management, and an extensive reusable UI component library. It includes browser extension support for web clipping and AI agent extensibility.
mcp-logseq is a Model Context Protocol (MCP) server that bridges AI agents (like Claude) to Logseq knowledge bases. It exposes Logseq's local HTTP API through 15+ tools for reading, creating, updating, and deleting pages and blocks, along with search, DSL queries, and optional semantic vector search via LanceDB. The server supports both stdio and HTTP/SSE transports with security features including namespace/tag-based access control, read-only mode, TLS, and bearer token authentication. The vector database is managed by a separate sync process (logseq-sync) to enforce a single-writer pattern. The codebase is well-architected with clean separation of concerns: a declarative access control system, a pure namespace matching utility, a stateful markdown parser, and an embedder abstraction with Ollama/OpenAI adapters. Configuration is lazy-cached from environment variables and a JSON config file, with no import-time side effects. The test suite is comprehensive with over 50 unit tests and integration tests for HTTP serving. While the project is still in beta, it demonstrates strong engineering practices and provides several reusable components for other MCP server implementations or Logseq integration tools.
Logseq is a privacy-first, open-source knowledge management platform built as a monorepo containing an Electron desktop app, Capacitor-based mobile apps (iOS/Android), a web app, and a Node.js db-sync server. The codebase is predominantly ClojureScript (CLJS) with React/Rum for the UI, DataScript for the in-memory graph database, and SQLite (via better-sqlite3 and sqlite-wasm) for persistence. It uses shadow-cljs for CLJS compilation, webpack for JS bundling, and Tailwind CSS for styling. A separate OCaml-based CLI (logseq-cli) built with Melange provides graph inspection, sync, and CRUD operations against the same db-worker-node backend. The architecture separates concerns into deps/ subprojects (db, outliner, graph-parser, db-sync, common, publishing, shui) that are compiled as separate shadow-cljs targets and shared across Electron, browser, mobile, and CLI runtimes. The system has two graph types: file-based graphs (Markdown/Org) and DB graphs (SQLite-backed with DataScript in-memory querying). DB graphs enable real-time collaboration (RTC) via a Cloudflare Worker-based sync server (deps/db-sync) using WebSockets and D1 SQLite. The db-worker-node is a long-lived Node.js process that manages SQLite connections and sync state, communicating with the UI via a thread-api IPC mechanism. The outliner module handles block tree operations with structural invariants, while the graph-parser handles Markdown/Org parsing via mldoc. The publishing module generates static HTML sites from graphs. Key architectural patterns include: missionary for reactive async flows, promesa for promise composition, malli for schema validation, datascript for Datalog queries, and a component-based UI with Rum/React. The codebase has extensive test coverage via cljs.test, Playwright E2E tests (clj-e2e), and Python-based CLI E2E tests (cli-e2e). The repository is actively maintained with recent commits, 43k+ stars, and active issue triage, though the large monorepo complexity and multi-language surface (CLJS, OCaml, Swift, Kotlin, Python, JS) create maintenance challenges.
SiYuan is a privacy-first, local-first personal knowledge management system with a block-based WYSIWYG editor, AI assistant integration, cloud sync, and a plugin ecosystem. It is architected as a Go kernel (Gin HTTP API + WebSocket) paired with a TypeScript/Electron frontend, supporting desktop (Windows, macOS, Linux), mobile (Android, iOS, HarmonyOS), and browser/Docker deployment. The kernel handles all data operations: block tree persistence as JSON `.sy` files, SQLite indexing with FTS5 and SQLCipher encryption, attribute-view databases (tables, galleries, kanban), backlink resolution, full-text search, and sync via multiple providers (SiYuan cloud, S3, WebDAV, LAN). The frontend provides a rich editing experience with Markdown, LaTeX, Mermaid, mind maps, PDF annotation, flashcards (FSRS), and an agent chat interface. External dependencies include the Lute Markdown parser, dejavu sync library, Pandoc for document conversion, and PDF.js for PDF rendering. The system exposes a comprehensive REST API with contract-based validation and auto-generated TypeScript types, enabling third-party integrations and a community marketplace for plugins, themes, and templates.
Answer Overflow is a full-stack platform that indexes Discord community conversations and makes them publicly searchable via the web, Google, and AI assistants. It consists of a Discord bot (built with discord.js and Effect-TS) that syncs messages, threads, and channels into a Convex backend, and a Next.js web application that renders these conversations as rich, SEO-optimized pages with search, thread cards, user profiles, and an AI-powered chat assistant. The bot handles features like solution marking, auto-threading, forum guidelines consent, and sitemap generation. The web app supports multiple tenants (custom domains) and includes a dashboard for server management, analytics, and subscription billing via Stripe. The architecture is a monorepo with shared packages for the database layer (typed Convex operations via Effect Schema), a custom React reconciler for Discord messages (Reacord), an AI agent component for streaming chat threads with vector search, and observability integrations (OpenTelemetry, Sentry, PostHog, Axiom). Effect-TS is used pervasively for dependency injection, error handling, and structured concurrency across the bot and web backend. The system is highly modular, testable (dedicated convex-test package and Effect-based test layers), and demonstrates advanced patterns in type-safe database access, real-time streaming, and Discord bot engineering.
Open Notebook is a self-hosted, AI-powered research assistant and knowledge management application. It allows users to collect sources (web pages, uploaded documents, text snippets), extract structured insights via LLM-driven transformations, organize content into notebooks, perform hybrid text/vector search, and generate AI podcasts with multi-speaker support using TTS models. The backend is built on Python with FastAPI and LangGraph for orchestration, SurrealDB for persistence (with a custom migration system), and the Esperanto library for multi-provider AI integration (OpenAI, Anthropic, Google, Ollama, and many others). The frontend is a modern Next.js application with React Query, i18n support for 14 locales, and a component library based on Radix UI/shadcn. The architecture follows a monolith-with-background-workers pattern: the FastAPI process handles both synchronous API requests and, via the surreal-commands library, asynchronous background jobs for content processing, embedding generation, and podcast generation. The codebase is well-structured with clear separation between API routers, domain models, utility modules, and frontend components. It exhibits strong security awareness—includes SSRF protection via DNS pinning, path containment for file uploads, Fernet encryption for stored credentials, and input validation throughout. The test suite is extensive (>100 test files) covering API endpoints, domain logic, error handling, and edge cases. There are some maintenance risks related to tight coupling with SurrealDB and the externally-maintained Esperanto/content-core/podcast-creator libraries, but overall the codebase is actively maintained and of professional quality.
ByteRover CLI is an AI-powered development assistant that provides persistent, structured memory for AI coding agents through a context tree. It features a multi-layered architecture with CLI (OCLIF), TUI (React Ink), and WebUI (React/Vite) interfaces, backed by a daemon service handling core agent logic. The system enables knowledge curation, synthesis, version control for context trees, swarm-based querying across multiple LLM providers, and integration with external AI agents via MCP. Key capabilities include tool execution (file operations, code execution), review workflows for AI-generated changes, and telemetry tracking.
obsidian.nvim is a Neovim plugin that integrates Obsidian vault functionality directly into Neovim. It provides note creation, linking, completion, navigation, image handling, synchronization, and templating features for markdown-based notes. The plugin leverages Neovim's API for LSP integration, autocommands, buffer management, and picker interfaces (telescope, fzf, snacks, mini) to deliver an Obsidian-like experience within Neovim. It maintains a cache of note metadata for performance and supports multiple workspaces with per-workspace overrides. The architecture is modular, separating concerns into commands, LSP handlers, note management, workspace handling, caching, search, picker abstraction, and completion sources.
TriliumNext/Trilium is a full-stack, cross-platform hierarchical note-taking application with rich text editing, LLM integration, sync, encryption, and a plugin-based architecture. The monorepo contains a Node.js Express server (SQLite backend), a Preact/React SPA client, an Electron desktop wrapper, a standalone browser-SQLite-WASM build, and a Capacitor mobile app. The system manages notes as a tree with cloning, attributes, relations, and multiple content types (text, code, mind maps, canvases, spreadsheets, calendars, etc.). It provides custom CKEditor5 plugins for math, footnotes, mermaid diagrams, and AI assistance, as well as a full-featured LLM chat with tool execution and skill sheets. The codebase is well-tested with over 2000 spec files, uses modern TypeScript and pnpm workspaces, and includes comprehensive import/export (Evernote, OneNote, Obsidian, Notion, Google Keep, OPML, Markdown, HTML) and sync capabilities. Key architectural patterns include a provider abstraction for platform-specific services (crypto, zip, messaging, clipboard), a component-based widget system on the client, and a centralized entity cache (becca/froca) that is synchronized via WebSocket.
Anytype for iOS is a full-featured, offline-first knowledge management and collaboration application. It provides a block-based editor for notes, documents, and databases (sets/collections), along with chat, spaces, widgets, and membership management. The architecture follows MVVM with a coordinator pattern, heavily leveraging SwiftUI for modern UI and UIKit for legacy editor components. Communication with the backend (middleware) is via protobuf-defined commands and events, with real-time subscription-based data synchronization. Dependency injection is handled through the Factory library, and the codebase is modular with separate packages for services, design system, core utilities, and generated protobuf models. The app supports iOS 17+ and uses Swift 6 concurrency features extensively.
53AIHub is an open-source enterprise AI knowledge management and agent orchestration platform. The codebase reveals a multi-tenant SaaS/self-hosted system that allows organizations to build, deploy, and operate AI agents across multiple backends (OpenAI, Coze, Dify, Gemini, etc.), manage knowledge bases with full RAG pipelines (document parsing, chunking, embedding, graph extraction, wiki generation), record and transcribe meetings with insight extraction, and provide a unified search and chat interface. The architecture is a Go monolith backend using Gin and GORM, with a monorepo frontend comprising three React apps (admin console, end-user portal, and embeddable agent plugin) sharing a common business logic and component library. Data flows center on document ingestion pipelines, real-time agent relay with tool execution, and recording/speech processing. The system integrates with vector stores (Qdrant), Elasticsearch, Redis, and various LLM providers. While primarily an application, it contains substantial data processing pipelines characteristic of a data_research project, particularly the RAG and recording insight modules.
chubbyskills is a personal knowledge management CLI toolkit that ingests content from over a dozen platforms (YouTube, Bilibili, X, Xiaohongshu, WeChat, Douyin, Podcasts, etc.), transcribes audio/video locally or via cloud providers, and outputs structured Markdown notes with YAML frontmatter (schema v1). The system is architected as a collection of modular "skills" (one per platform) orchestrated by a unified CLI (`tools/chubby.py`), with shared utilities in `chubby_common/`. It includes an incremental knowledge base indexer using SQLite FTS5 and optional semantic embeddings, an MCP server exposing six tools for AI agent integration, and a deterministic evidence brief generator with integrity validation. Operation is local-first: transcription uses SenseVoice and faster-whisper, video downloading uses yt-dlp, and all processing is designed to work offline. Cloud transcription (Atlas/MuAPI) and LLM enrichment (DeepSeek) are optional extensions. The repository also provides a skill installer, platform smoke testing, output validation, and retry mechanisms with credential redaction. Despite the breadth, the codebase maintains clean separation of concerns, with the shared library standing out as a reusable zero-dependency core.
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.
GistPad MCP is a Model Context Protocol (MCP) server that provides a comprehensive interface for managing GitHub Gists through AI assistants like GitHub Copilot and Claude Desktop. It exposes tools for CRUD operations on gists, file management within gists, comments, daily notes, archiving, starring, and reusable prompts. The server runs over stdio and uses the GitHub REST API via a custom typed fetch client. It features a caching layer with hourly refresh, resource subscriptions, and change notifications. The codebase is written in modern TypeScript (ES2024, Node.js 22+) with strict type safety, comprehensive tests for the file editing tool, and a clean modular architecture separating concerns into tools, server, store, and utilities. It demonstrates strong engineering practices including abstract base classes for stores, automatic tool annotation derivation, and careful error handling.
ReadAny is a full-featured, cross-platform e-book reader application with deep AI integration. It supports reading EPUB, PDF, MOBI, FB2, and other formats via the modified foliate-js engine, and provides text-to-speech, annotations, reading statistics, and cross-device sync (WebDAV, S3, LAN). The AI subsystem offers chat with RAG (semantic search over book content), context-aware tools, and execution of user-defined skills. The application follows a local-first architecture with robust offline capabilities and optional cloud sync. The codebase is structured as a pnpm monorepo with four main packages: 'core' (shared business logic, types, stores, AI, RAG, sync, stats, TTS), 'app' (Tauri desktop client with React+shadcn UI), 'app-expo' (Expo/React Native mobile client), and 'cli' (agent integration via MCP and managed shims). The application exhibits high craftsmanship in its platform abstraction layer, persistent store pattern, and hybrid search engine. However, there is significant platform-driven code duplication (desktop vs. mobile UI components) and a complex dependency graph with multiple patched packages, indicating some architectural debt.
TidGi-Desktop is a cross-platform Electron application that integrates TiddlyWiki (a personal wiki) with AI agent capabilities, Git synchronization, and modern desktop features. It allows users to manage multiple workspaces (folder-based or single-file HTML wikis), sync with Git remotes, and interact with AI agents for chat, tool execution, and knowledge management. The architecture is Electron multi-process with main process, renderer processes (multiple windows), and a utility process for wiki worker. Services are wired via Inversify DI container and communicate via typed IPC (electron-ipc-cat). Key entry points include src/main.ts (Electron main), src/renderer.tsx (React renderer), src/services/agentInstance/ (AI agent lifecycle), src/services/wiki/ (wiki management), and src/services/git/ (Git operations). External dependencies include TiddlyWiki, Git (via dugite), SQLite (TypeORM), various AI SDKs (OpenAI, Anthropic, etc.), OAuth providers, and system-level integrations. The codebase is well-structured with a service-oriented architecture, extensive test coverage (unit, E2E, BDD), and a rich preference system driven by Zod schemas. It demonstrates high craftsmanship in areas like AI prompt concatenation, tool registration, and file system watching, though some modules are tightly coupled to the application's domain.