obsidian-copilot

Enables freeform conversational chat with LLM models from 15+ providers (OpenAI, Anthropic, Groq, DeepSeek, local Ollama, etc.) by maintaining a provider abstraction layer that normalizes API calls across different chat model interfaces. Context is injected from selected notes, folders, or tags via a context envelope system that prepares markdown content for inclusion in the prompt. The plugin streams responses token-by-token back to the chat UI, maintaining conversation history as persistent markdown notes in the vault.

Provides dual-mode search across the entire vault: BM25+ lexical search (free tier) for keyword-based retrieval and optional embedding-backed vector search (Orama or Miyo) for semantic similarity matching. The indexing system maintains an inverted index of vault notes and can optionally compute embeddings via external providers. When a user queries, the system retrieves relevant notes ranked by relevance and injects them as context into the LLM chat, enabling vault-wide question-answering without manual note selection.

Allows users on the self-host tier to replace Brevilabs-hosted backend services with self-hosted alternatives: Miyo (embedding service), Firecrawl (web scraping and document conversion), and Perplexity (web search). This enables fully local deployments where no data leaves the user's infrastructure, addressing privacy and compliance requirements. Configuration is via settings UI where users provide URLs to their self-hosted services.

Automatically saves chat conversations as markdown files in the vault, with each conversation stored as a separate note containing the full message history (user messages, AI responses, timestamps). Users can browse, search, and reference past conversations like any other vault note. Conversation files are stored in a designated folder and can be organized by date, project, or custom tags.

Implements a provider abstraction layer (ChatModelProviders enum in src/constants.ts) that normalizes API calls across 15+ heterogeneous LLM providers (OpenAI, Anthropic, Groq, DeepSeek, Mistral, Ollama, LM Studio, etc.). The abstraction handles provider-specific authentication, request/response formatting, streaming protocols, and error handling. Users can switch providers in settings without changing their workflow, and the plugin automatically adapts to each provider's capabilities (e.g., function calling, vision, etc.).

Streams LLM responses token-by-token directly into the Obsidian chat UI, rendering each token as it arrives from the provider. This provides real-time feedback to users and reduces perceived latency compared to waiting for the full response. The streaming implementation handles provider-specific streaming protocols (Server-Sent Events for OpenAI, streaming for Anthropic, etc.) and gracefully handles network interruptions.

Provides a comprehensive settings interface where users configure LLM providers (API keys, model names, endpoints), embedding providers, search settings, and plugin behavior. The settings UI includes dropdowns for provider selection, text fields for API keys, and toggles for optional features. Settings are persisted to Obsidian's local storage and validated on save. The UI dynamically shows provider-specific options (e.g., Azure OpenAI requires endpoint URL and deployment name).

Allows users to request AI-generated edits to notes via a 'Composer' mode that generates suggested changes, displays them as a side-by-side diff, and applies them back to the vault with a single click. The system uses the LLM to generate edited markdown content, compares it against the original note, and renders the diff in the UI. Users can accept or reject changes before they're written back to disk, providing a safety mechanism for AI-assisted writing.

Enables users to define reusable AI prompts as markdown files with variable placeholders (e.g., {{selectedText}}, {{fileName}}) that are substituted at runtime. When a user invokes a custom command, the plugin reads the markdown template, substitutes variables with current context (selected text, file name, date, etc.), and sends the resulting prompt to the LLM. This allows non-technical users to create domain-specific prompts without touching code.

Implements a ReAct (Reasoning + Acting) agent that iteratively reasons about tasks, calls tools (vault search, web search, note composition), observes results, and decides next steps. The agent uses function calling (supported by OpenAI, Anthropic, Groq, etc.) to invoke tools like 'search_vault', 'search_web', 'compose_note', and 'read_memory'. The loop continues until the agent decides the task is complete or a max iteration limit is reached. This enables multi-step workflows like 'research a topic, find related notes, and draft a summary' without user intervention.

Allows the autonomous agent to read and write persistent memory notes stored in the vault, enabling it to maintain state across conversations and build long-term context. The agent can create new memory notes, update existing ones, and retrieve them in future sessions. This enables use cases like tracking project progress, maintaining a research log, or building a personal knowledge graph that the agent can reference and update autonomously.

Enables users to attach images to chat messages and send them to vision-capable LLM models (e.g., GPT-4V, Claude 3 Vision, Gemini Vision). The plugin handles image encoding (base64 or URL), constructs the appropriate API request for the chosen provider, and streams the model's response back to the chat. This allows users to ask questions about images, extract text via OCR, analyze diagrams, or get visual feedback without leaving Obsidian.

Displays a sidebar panel that shows notes semantically related to the current chat or selected note, combining two ranking signals: link-graph proximity (notes linked via backlinks/forward links) and semantic similarity (via embeddings). The sidebar updates dynamically as the user chats, surfacing notes that might be relevant to the conversation without explicit search. This provides passive discovery of related notes and helps users understand the structure of their knowledge base.

Allows users to define 'projects' that scope the AI's context to specific folders, tags, or external URLs. When a project is active, the AI only searches and retrieves notes within the project's boundaries, preventing context pollution from unrelated notes. Projects can combine multiple context sources (e.g., 'folder: /research AND tag: #active') and can include external URLs for web-based documentation. This enables multi-project workflows where users switch between isolated contexts.

Enables users to upload PDF, EPUB, or DOCX files, which are converted to markdown via Brevilabs-hosted backend (or self-hosted Firecrawl for self-host tier). The converted markdown is stored in the vault and can be searched, referenced, and discussed with the AI. This allows users to import external documents into their knowledge base without manual transcription.