Blinko

Blinko is a lightweight, self‑hosted note‑taking platform that blends AI‑powered retrieval with an ultra‑fast, Markdown‑centric workflow. The core idea is to let developers embed a high‑performance note store into their own infrastructure while still exposing powerful RAG (Retrieval‑Augmented Generation) search capabilities. The application is written in Rust, harnessing the Tauri framework for desktop clients and a minimal web server that serves both the SPA front‑end and the RAG API. This combination gives Blinko a small footprint, native binary support for macOS/Windows/Linux/Android, and a single‑binary deployment model that is ideal for containerized environments.

Technical Stack

Blinko’s architecture is intentionally single‑process: the Tauri client talks to the Actix server over a local HTTPS endpoint, and the same process hosts the AI inference loop. This eliminates inter‑process communication overhead and simplifies deployment.

Core Capabilities

• Card Notes – Each note is a plain‑text card with optional Markdown formatting. The UI supports drag‑and‑drop reordering and tagging.
• AI‑Enhanced Search – RAG is implemented using a lightweight FTS5 vector index; queries are passed to an LLM and the results are returned as a markdown snippet.
• Offline Voice Recognition – On Windows, Whisper is bundled to provide local speech‑to‑text without network calls.
• REST & WebSocket API – Exposes CRUD endpoints (/notes, /search) and a streaming endpoint for live AI responses. These can be consumed by custom front‑ends or integrated into CI/CD pipelines.
• Webhooks – Trigger external services on note creation/update via configurable URLs.

Deployment & Infrastructure

• Self‑Hosting – A single binary plus SQLite file is all that’s required. No external database or cache is needed.
• Containerization – Official Docker images are available; docker run -p 8080:80 blinkospace/blinko is sufficient. Environment variables control the OpenAI key, port, and optional Whisper path.
• Scalability – For multi‑user scenarios, a shared SQLite instance is not ideal. A simple migration to Postgres or MySQL can be achieved by swapping the rusqlite driver with a sqlx backend; the codebase already supports generic SQL via traits.
• High Availability – The stateless Actix server can be replicated behind a load balancer. The SQLite file must be shared via NFS or an object store for consistent state.

Integration & Extensibility

• Plugin System – Blinko ships with a plugin API that allows developers to inject custom Rust modules. Plugins can register new endpoints, modify note rendering, or add AI models.
• Custom LLMs – The RAG pipeline is pluggable; swap OpenAI with HuggingFace, Cohere, or a locally hosted model by changing the provider struct.
• Webhooks & Scripting – External services can subscribe to note events. A built‑in scripting engine (JavaScript via quickjs) lets users write small automation scripts that run on the server.

Developer Experience

• Configuration – All settings are exposed via environment variables (B_LINKO_OPENAI_KEY, B_LINKO_DB_PATH, etc.). The README and Docs site (docs.blinko.space) provide clear guidance on each option.
• Documentation – The project hosts comprehensive API docs generated with cargo doc and an online reference site. Inline comments are plentiful, making the Rust code approachable for contributors.
• Community – The repository has an active issue tracker, a dedicated Telegram channel (English/Chinese), and a GitHub Discussions forum. Contributors can submit PRs for new AI models, UI tweaks, or platform support.

Use Cases

1. Personal Knowledge Base – Developers can run Blinko locally to store code snippets, design notes, or research findings, retrieving them via natural language.
2. Team Collaboration – With the API and webhook support, Blinko can act as a lightweight internal wiki for small teams or side projects.
3. CI/CD Integration – Automate note creation from build logs, test reports, or deployment scripts by calling the /notes endpoint.
4. AI‑Driven Documentation – Use Blinko’s RAG to surface relevant documentation snippets when writing code or drafting PRs.

Advantages