Khoj is an open-source personal AI assistant functioning as a 'second brain' for interacting with personal knowledge bases. It provides a chat interface allowing users to converse with various AI models about documents, notes, and connected data sources (local files, GitHub, Notion). The system supports multimodal capabilities including image generation, code execution, voice input/output, and computer operation through a modular agent architecture. Khoj features a Python/Django backend with FastAPI for API endpoints, a PostgreSQL database with pgvector for vector storage and search, and multiple frontends including a web application (React/Next.js), desktop client (Electron), mobile app (Android), and plugins for Obsidian and Emacs. The architecture emphasizes separation of concerns with distinct modules for file processing, embedding generation, conversation handling, tool integration, and user management.
This is an Obsidian plugin that provides a highly configurable markdown linter and formatter. It implements over 50 individual rules organized by type (YAML, headings, content, spacing, footnotes, paste) using a clean rule-builder pattern with decorators. The plugin integrates deeply with the Obsidian editor, supporting lint-on-save, paste transformations, custom commands, regex replacements, and a comprehensive settings UI with tabs and search. It includes an extensive test suite (unit and integration) and auto-generates documentation from rule definitions. The architecture is modular: each rule is a self-registering class with typed options, examples, and option builders that also drive the settings UI. Shared utilities for YAML manipulation, markdown AST transformations, and ignore-type masking are well-isolated and reusable. The codebase is actively maintained with frequent commits and responsive issue triage.
This Obsidian plugin enables users to make HTTP API requests directly from within their notes using markdown code blocks. It processes 'req' language blocks to execute GET, POST, PUT, DELETE, PATCH, HEAD, and OPTIONS requests, with support for variable substitution from frontmatter, global variables, and cached responses. The plugin emphasizes security through comprehensive input validation, URL sanitization, JSONPath expression validation, and XSS prevention in output formatting. The architecture separates concerns between the main request processing logic, security utilities, and Obsidian-specific integration points. Key features include response caching via localStorage with unique identifiers, automatic variable resolution, JSONPath-based data extraction, customizable output formatting, and the ability to save responses to files or update frontmatter properties. The plugin implements defense-in-depth security practices to protect against common web vulnerabilities while providing a flexible API integration tool for knowledge workers.
This repository is a CSS theme for the Obsidian note-taking application, designed to replicate the visual aesthetic of the Things 3 task manager. The codebase consists of a single `theme.css` file that overrides Obsidian's default styling using CSS custom properties, class overrides, and media queries. It provides both light and dark color schemes, custom checkbox icons via CSS mask images, progress bar coloring based on percentage, and extensive integration with community plugins like Kanban, Calendar, Todoist, and Checklist. The theme also includes a comprehensive set of user-customizable settings exposed through the Style Settings plugin. This is a pure presentation layer with no application logic, data processing, or dependencies beyond Obsidian itself.
This is an Obsidian plugin that extends the built-in `obsidian://` URI scheme with additional `x-callback-url` endpoints for automation. It provides a modular routing system with endpoints for notes (CRUD, append/prepend, search/replace, touch), files, folders, vault info, commands, search, Dataview queries, Omnisearch, tags, and note properties. The architecture is modular: each route is defined in its own file under `src/routes/`, with Zod schemas for parameter validation and handler functions that return standardized success/failure objects. The main entry point is `src/main.ts`, which registers URI handlers and manages plugin lifecycle. Incoming URIs are matched to routes, parameters are validated and transformed (e.g., resolving file paths, UIDs, periodic notes), and the handler executes the requested action, sending callbacks via `x-success`/`x-error` URLs. External dependencies include the Obsidian API, Zod, `obsidian-daily-notes-interface`, `obsidian-dataview`, and `filter-obj`. The plugin also relies on third-party plugins (Templater, Periodic Notes, Dataview, Omnisearch) for certain routes. The codebase is well-structured with TypeScript, esbuild bundling, Jest E2E tests using a custom callback server, and comprehensive documentation.
This repository is the Meta Bind plugin for Obsidian, a note-taking application. It allows users to embed interactive input fields, view fields, buttons, and tables directly into Markdown notes, bound to frontmatter metadata or in-memory data. The plugin parses a custom DSL (e.g., `INPUT[type: text]`, `VIEW[...]`, `BUTTON[...]`) using a custom parser library (parsinom) and renders Svelte components that read and write metadata values. It supports over 20 input field types (text, number, slider, toggle, select, date, etc.), view fields with math expressions and markdown rendering, and button actions (commands, JS execution, note creation, metadata updates, etc.). The architecture is a monorepo with three packages: `core` (platform-independent logic), `obsidian` (Obsidian desktop adapter), and `publish` (Obsidian Publish adapter). The core package contains all parsing, configuration, field implementations, metadata management, and Svelte UI components. The obsidian package integrates with Obsidian's plugin API, CodeMirror editor, and metadata cache. The publish package provides a limited subset for Obsidian Publish. In production, the plugin operates as a Markdown post-processor and a CodeMirror view plugin. When a note is rendered, it scans for DSL declarations, parses them into field configurations, creates mountable field components, and binds them to metadata sources (frontmatter, YAML, in-memory caches). Changes in input fields propagate back to metadata and trigger updates to other bound fields. The plugin also provides a public API for other plugins (e.g., JS Engine) to create fields programmatically. External dependencies include Obsidian's own API, and optional integrations with the Dataview, Templater, and JS Engine plugins. The codebase demonstrates strong software engineering practices: clean separation of concerns, extensive use of factory and strategy patterns, a reactive metadata subscription system, and a comprehensive test suite. However, there are signs of technical drift such as commented-out code, some type safety workarounds, and a large parameterized test file that is difficult to maintain. Overall, it is a well-crafted, feature-rich plugin with reusable components that could be extracted for other projects.
ZotLit is a dual-plugin system (Obsidian plugin + Zotero addon) that bridges Zotero's reference management with Obsidian's note-taking environment. It enables users to create literature notes from Zotero items, insert formatted citations, import annotations, and export documents via Pandoc — all within Obsidian. The system is a monorepo with three main applications: an Obsidian plugin (apps/obsidian) that provides views (annotation sidebar, references panel, citation popover, template data explorer), services (citation indexing, live updates from Zotero, Pandoc integration, note creation/update), and a settings tab; a Zotero addon (apps/zotero) that extends Zotero's menus, database status, and freshness signaling; and a documentation site (apps/docs) built with TanStack Router and Fumadocs on Cloudflare Workers. The architecture is service-oriented on the Obsidian side, with approximately 20 services wired in a service container (build.ts) using AsyncDisposableStack for lifecycle management. Shared packages (@zotlit/db, @zotlit/templates, @zotlit/protocol, @zotlit/obsidian-i18n, @zotlit/item-lookup) provide database queries over Zotero's SQLite via Drizzle ORM, template rendering with Eta/Liquid engines, a versioned HTTP wire protocol between Zotero and Obsidian, i18n Language Pack compilation, and a search index for item lookup. The codebase is well-tested with Vitest, employs modern TypeScript patterns, and maintains a comprehensive typed contract system for template data. Key workflows include: bidirectional citation linking (pandoc-style and wikilink), live preview of citations in reading view, annotation import from PDF/EPUB/snapshots with turndown HTML-to-Markdown conversion, Pandoc export with a bundled Lua filter and pinned WASM engine, batch note creation from collection selections, and a template workbench CLI for debugging and authoring templates. The system relies on Zotero's local SQLite database as the authoritative source, with a freshness detection mechanism (WAL checkpoint polling) to trigger updates in Obsidian.
This repository is an Obsidian plugin that integrates GitHub Copilot's AI-powered coding assistance directly into the Obsidian note-taking application. It provides two main features: inline code suggestions as you type (similar to Copilot in IDEs) and a chat interface for interacting with Copilot in a sidebar. The plugin handles authentication with GitHub Copilot, manages conversation history, renders Mermaid diagrams from AI responses, and allows linking to Obsidian notes using [[double bracket]] syntax in chat conversations. The architecture separates concerns into distinct modules for inline suggestions (using LSP protocol) and chat functionality (using direct API calls), with React powering the chat UI and Zustand managing state.
Make.md is an Obsidian plugin (manifest id `make-md`) that turns a plain vault into a structured knowledge workspace. In production it registers custom leaf views (Spaces, Navigator, Blink), patches Obsidian's workspace and CodeMirror editor, and maintains a metadata layer called `Superstate` indexed by web workers. It ships a React-based frame layout engine where notes/spaces are rendered as configurable frame trees with style/action expressions evaluated at runtime, an MDB layer that reads and writes SQLite `.mdb` files via sql.js, and a predicate/filter/aggregate system powering table, calendar, list, and chart views. The plugin also includes a custom mathjs-based formula language, an HTML export pipeline, and a D3-driven visualization pipeline.