GitHub - kenforthewin/atomic · GitHub

Skip to content

Navigation Menu

Toggle navigation

Sign in

Appearance settings

PlatformAI CODE CREATIONGitHub CopilotWrite better code with AIGitHub SparkBuild and deploy intelligent appsGitHub ModelsManage and compare promptsMCP RegistryNewIntegrate external toolsDEVELOPER WORKFLOWSActionsAutomate any workflowCodespacesInstant dev environmentsIssuesPlan and track workCode ReviewManage code changesAPPLICATION SECURITYGitHub Advanced SecurityFind and fix vulnerabilitiesCode securitySecure your code as you buildSecret protectionStop leaks before they startEXPLOREWhy GitHubDocumentationBlogChangelogMarketplaceView all featuresSolutionsBY COMPANY SIZEEnterprisesSmall and medium teamsStartupsNonprofitsBY USE CASEApp ModernizationDevSecOpsDevOpsCI/CDView all use casesBY INDUSTRYHealthcareFinancial servicesManufacturingGovernmentView all industriesView all solutionsResourcesEXPLORE BY TOPICAISoftware DevelopmentDevOpsSecurityView all topicsEXPLORE BY TYPECustomer storiesEvents & webinarsEbooks & reportsBusiness insightsGitHub SkillsSUPPORT & SERVICESDocumentationCustomer supportCommunity forumTrust centerPartnersView all resourcesOpen SourceCOMMUNITYGitHub SponsorsFund open source developersPROGRAMSSecurity LabMaintainer CommunityAcceleratorGitHub StarsArchive ProgramREPOSITORIESTopicsTrendingCollectionsEnterpriseENTERPRISE SOLUTIONSEnterprise platformAI-powered developer platformAVAILABLE ADD-ONSGitHub Advanced SecurityEnterprise-grade security featuresCopilot for BusinessEnterprise-grade AI featuresPremium SupportEnterprise-grade 24/7 supportPricing

Search or jump to...

Search code, repositories, users, issues, pull requests...

Search

Clear

Search syntax tips

Provide feedback

We read every piece of feedback, and take your input very seriously.

Include my email address so I can be contacted

Cancel

Submit feedback

Saved searches

Use saved searches to filter your results more quickly

Name

Query

To see all available qualifiers, see our documentation.

Cancel

Create saved search

Sign in

Sign up

Appearance settings

Resetting focus

You signed in with another tab or window. Reload to refresh your session.
You signed out in another tab or window. Reload to refresh your session.
You switched accounts on another tab or window. Reload to refresh your session.

Dismiss alert

kenforthewin

/

atomic

Public

Notifications
You must be signed in to change notification settings

Fork
0

Star
4

Code

Issues
0

Pull requests
0

Actions

Projects

Security
0

Insights

Additional navigation options

Code

Issues

Pull requests

Actions

Projects

Security

Insights

kenforthewin/atomic

 mainBranchesTagsGo to fileCodeOpen more actions menuFolders and filesNameNameLast commit messageLast commit dateLatest commit History203 Commits203 Commits.cargo.cargo  .github/workflows.github/workflows  atomic_syncatomic_sync  cratescrates  dockerdocker  docsdocs  extensionextension  iosios  publicpublic  scriptsscripts  src-taurisrc-tauri  srcsrc  .dockerignore.dockerignore  .gitignore.gitignore  AGENTS.mdAGENTS.md  CLAUDE.mdCLAUDE.md  Cargo.lockCargo.lock  Cargo.tomlCargo.toml  DockerfileDockerfile  LICENSELICENSE  README.mdREADME.md  ROADMAP.mdROADMAP.md  docker-compose.ymldocker-compose.yml  fly.toml.examplefly.toml.example  index.htmlindex.html  package-lock.jsonpackage-lock.json  package.jsonpackage.json  tsconfig.jsontsconfig.json  tsconfig.node.jsontsconfig.node.json  vite.config.tsvite.config.ts  View all filesRepository files navigationREADMEMIT licenseAtomic
A personal knowledge base that turns markdown notes into a semantically-connected, AI-augmented knowledge graph.
Atomic stores knowledge as atoms — markdown notes that are automatically chunked, embedded, tagged, and linked by semantic similarity. Your atoms can be synthesized into wiki articles, explored on a spatial canvas, and queried through an agentic chat interface.

Features

Atoms — Markdown notes with hierarchical tagging, source URLs, and automatic chunking
Semantic Search — Vector search over your knowledge base using sqlite-vec
Canvas — Force-directed spatial visualization where semantic similarity determines layout
Wiki Synthesis — LLM-generated articles with inline citations, built from your notes
Chat — Agentic RAG interface that searches your knowledge base during conversation
Auto-Tagging — LLM-powered tag extraction organized into hierarchical categories
Multiple AI Providers — OpenRouter (cloud) or Ollama (local) for embeddings and LLMs
RSS Feeds — Subscribe to feeds and automatically sync new articles as atoms
Browser Extension — Capture web content directly into Atomic
MCP Server — Expose your knowledge base to Claude and other AI tools
Multi-Database — Multiple knowledge bases with a shared registry
iOS App — Native SwiftUI client for reading and writing atoms on mobile

Getting Started
Atomic runs as a desktop app (Tauri), a headless server (Docker/Fly.io), or both.
Desktop App
Download the latest release for your platform from GitHub Releases (macOS, Linux, Windows).
On first launch, the setup wizard walks you through AI provider configuration.
Self-Host with Docker Compose
git clone https://github.com/kenforthewin/atomic.git
cd atomic
docker compose up -d
This starts the API server and web frontend. Open http://localhost and claim your instance through the setup wizard.
Deploy to Fly.io
cp fly.toml.example fly.toml
fly launch --copy-config --no-deploy
fly volumes create atomic_data --region <your-region> --size 1
fly deploy
Open https://your-app.fly.dev and claim your instance. The public URL for OAuth/MCP is auto-detected from the Fly app name.
Standalone Server
cargo run -p atomic-server -- --data-dir ./data serve --port 8080
On first run, create an API token:
cargo run -p atomic-server -- --data-dir ./data token create --name default
AI Provider Setup
Atomic needs an AI provider for embeddings, tagging, wiki generation, and chat.

OpenRouter (cloud) — Get an API key from openrouter.ai. Supports separate model selection for embedding, tagging, wiki, and chat.
Ollama (local) — Install Ollama and pull models (e.g., ollama pull nomic-embed-text). Atomic auto-discovers available models.

Configure via the setup wizard on first launch, or later in Settings.
Browser Extension
The Atomic Web Clipper captures web content as atoms:

Open Chrome/Edge/Brave and navigate to chrome://extensions
Enable "Developer mode"
Click "Load unpacked" and select the extension/ directory
Configure your server URL and API token in the extension options

Captures are queued offline and synced when the server is available.
MCP Server
Atomic exposes an MCP endpoint for Claude and other AI tools to search and create atoms.
The endpoint runs at /mcp on your server (e.g., http://localhost:8080/mcp).
Claude Desktop config (~/Library/Application Support/Claude/claude_desktop_config.json):
{
"mcpServers": {
"atomic": {
"url": "http://localhost:44380/mcp"
}
}
}
Available tools: semantic_search, read_atom, create_atom
Architecture
All business logic lives in atomic-core, a standalone Rust crate with no framework dependencies. Every client is a thin wrapper adapting it to a transport:
+------------------+
| atomic-core |
| (all logic) |
+--------+---------+
+--------------+--------------+
v v v
+-----------+ +--------------+ +----------+
| src-tauri | |atomic-server | |atomic-mcp|
| (desktop) | | (REST + WS) | | (stdio) |
+-----+-----+ +------+-------+ +----------+
| |
+-----v-----+ +------v-------+
| React UI | | HTTP clients |
| | | (iOS, web) |
+------------+ +--------------+

Project Structure
Cargo.toml # Workspace root
crates/atomic-core/ # All business logic
crates/atomic-server/ # REST + WebSocket + MCP server
crates/atomic-mcp/ # Standalone MCP server (stdio)
crates/mcp-bridge/ # HTTP-to-stdio MCP bridge
src-tauri/ # Tauri desktop app
src/ # React frontend (TypeScript)
ios/ # Native iOS app (SwiftUI)
extension/ # Chromium browser extension
scripts/ # Import and utility scripts

Development
Prerequisites

Node.js 22+
Rust toolchain (rustup)
For the desktop app: platform-specific Tauri v2 dependencies

Commands
npm install # Install frontend dependencies

# Desktop app
npm run tauri dev # Dev with hot reload
npm run tauri build # Production build

# Server only
cargo run -p atomic-server -- serve --port 8080

# Frontend only
npm run dev # Vite dev server

# Checks
cargo check # All workspace crates
cargo test # All tests
npx tsc --noEmit # Frontend type check
Tech Stack

Layer
Technology

Core
Rust, SQLite + sqlite-vec, tokio

Desktop
Tauri v2

Server
actix-web

Frontend
React 18, TypeScript, Vite 6, Tailwind CSS v4, Zustand 5

Editor
CodeMirror 6

Canvas
d3-force, react-zoom-pan-pinch

iOS
SwiftUI, XcodeGen

AI
OpenRouter or Ollama (pluggable)

License
MIT

About

No description, website, or topics provided.

Resources

Readme

License

MIT license

Uh oh!

There was an error while loading. Please reload this page.

Activity
Stars

4
stars
Watchers

0
watching
Forks

0
forks

Report repository

Releases
24

Atomic v1.0.2

Latest

Mar 21, 2026

+ 23 releases

Packages
0

Uh oh!

There was an error while loading. Please reload this page.

Contributors
2

kenforthewin
Kenneth Bergquist

redoswald

Languages

Rust
48.7%

TypeScript
39.5%

JavaScript
6.4%

Swift
4.2%

CSS
0.6%

Dockerfile
0.3%

Other
0.3%

Footer

© 2026 GitHub, Inc.

Footer navigation

Terms

Privacy

Security

Status

Community

Docs

Contact

Manage cookies

Do not share my personal information

You can’t perform that action at this time.

Atomic is a personal knowledge base designed to synthesize and augment your notes using artificial intelligence. Developed by Kenforthewin, the project utilizes a layered architecture combining Rust for core logic, React for the frontend, and Tauri for the desktop application. Its primary function is to transform markdown notes into a semantically connected knowledge graph, employing features like automatic chunking, semantic searching via sqlite-vec and a spatial canvas visualization, and LLM-driven wiki synthesis. The system also includes an agentic chat interface for querying the knowledge base and is designed to integrate with various AI providers, initially supporting OpenRouter (cloud) or Ollama (local) for embeddings and LLMs. A browser extension facilitates capturing web content as atomic notes, while an MCP Server (Microservice Communications Protocol) allows integration with tools like Claude, extending its capabilities.

The project’s core relies on a single Rust crate, `atomic-core`, eliminating framework dependencies to maximize control and maintainability. The architecture includes a dedicated server, `atomic-server`, handling REST and WebSocket requests, alongside a standalone MCP server (`atomic-mcp`) that accepts input from the stdio, facilitating communication with AI services. A React frontend, built with Vite and Tailwind, provides an intuitive user interface for managing and exploring the knowledge graph. The desktop application utilizes Tauri, a framework for building cross-platform desktop apps using web technologies, allowing deployment on macOS, Linux, and Windows. A native iOS app, developed using SwiftUI, complements the desktop experience, enabling access to the knowledge base on mobile devices. Further enhancing the system's functionality is a web clipper extension for Chrome and Edge, synchronizing captured content with the server.

The setup process offers multiple avenues for deployment, including a self-hosted Docker Compose setup, providing a streamlined way to launch the API and web frontend. Alternatively, deployment to Fly.io offers a simplified deployment process utilizing Fly's services. The project incorporates a modern tech stack, leveraging technologies like Rust, React, Vite, and SQLite to deliver a robust and scalable knowledge management solution. The development process is divided into stages, with comprehensive commands for managing the frontend, backend, and server components. The system’s design prioritizes modularity and pluggability, allowing developers to easily integrate with different AI providers and adapt the system to specific needs. The project's core code is housed within the `atomic-core` crate, while client applications are wrappers that translate between the core functionality and transport protocols.