Thoth is a local-first AI assistant built for personal AI sovereignty — your models, your data, your rules. It combines a powerful ReAct agent with 25 integrated tools (79 sub-operations) — web search, email, calendar, file management, shell access, browser automation, vision, image generation, X (Twitter), long-term memory with a personal knowledge graph, advanced workflows with conditional branching and approval gates, habit tracking, and more — plus a plugin system with a built-in marketplace and 5 messaging channels (Telegram, WhatsApp, Discord, Slack, SMS) with full media support, streaming, reactions, and per-channel tool generation. Run everything locally via Ollama, or add opt-in cloud models from OpenAI, Anthropic (Claude), Google AI (Gemini), xAI (Grok), and OpenRouter (100+ models) when you need frontier reasoning or don't have a GPU. Either way, your data — conversations, memories, documents, and history — stays on your machine.

Local models are already amazing. You'll be surprised what a 14B+ local model can do. If you start with cloud models today, and as local models get smarter and hardware gets cheaper, transition to fully local, fully private, fully free AI — seamlessly, with no changes to your setup.

Governments are investing billions to keep AI infrastructure within their borders. Thoth applies the same principle to the individual — your compute, your data, your choice of model, accountable to no one but you.

🖥️ One-click install on Windows & macOS — download, run, done. No terminal, no Docker, no config files. Get it here.

Demo 1 — Power User	Demo 2 — Small Business
Demo 3 — Researcher	Demo 4 — Developer

In ancient Egyptian mythology, Thoth (𓁟) was the god of wisdom, writing, and knowledge — the divine scribe who recorded all human understanding. Like its namesake, this tool is built to gather, organize, and faithfully retrieve knowledge — while keeping everything under your control.

📖 Every feature below is documented in full technical detail in docs/ARCHITECTURE.md.

LangGraph-based autonomous agent with 25 tools / 79 sub-operations — the agent decides which tools to call, how many times, and in what order. Real-time token streaming with thinking model support (DeepSeek-R1, Qwen3, QwQ — collapsible reasoning bubbles). Smart context management via tiktoken: auto-summarization at 80% capacity, proportional tool-output shrinking, and dynamic tool budgets that adapt to available headroom. Destructive actions require explicit confirmation; orphaned tool calls are auto-repaired; recursive loops are caught with a wind-down warning at 75%.

Details →

Thoth builds a personal knowledge graph — entities (person, place, event, preference, fact, project, organisation, concept, skill, media) linked by 67 typed directional relations with 60+ aliases (Dad --[father_of]--> User), with alias resolution, auto-linking on save, memory decay, and background orphan repair. Vague relation types (related_to, associated_with, etc.) are automatically rejected; relation pre-normalisation ensures consistent naming. The agent can save, search, link, and explore memories through natural conversation. Graph-enhanced auto-recall retrieves semantically similar entities via FAISS and expands 1 hop in the NetworkX graph before every LLM call. An interactive Knowledge tab visualizes the full graph with search, entity-type filters, ego-graph toggle, and clickable detail cards. Background extraction produces structured triples with deterministic cross-category dedup; conservative extraction filters skip workflow threads, truncate assistant messages, and apply an 0.80 confidence floor to prevent junk entities.

Details →

Export the entire knowledge graph as an Obsidian-compatible markdown vault — one .md file per entity with YAML frontmatter, [[wiki-links]], and per-type indexes. Entities grouped by type (wiki/person/, wiki/project/, …); sparse entities roll up into index files. Live export on save/delete, full-text search, and conversation export. The agent has 4 sub-tools (wiki_read, wiki_rebuild, wiki_stats, wiki_export_conversation) to interact with the vault directly.

Details →

A 4-phase background daemon that refines the knowledge graph during idle hours — merging duplicates (≥0.93 similarity), enriching thin descriptions from conversation context, inferring missing relationships between co-occurring entities, and decaying stale confidence on relations older than 90 days. Hub diversity caps, batch rotation, and a 7-day rejection cache ensure high-quality, non-repetitive inferences. Three-layer anti-contamination system prevents cross-entity fact-bleed. Ollama busy check defers cycles when the GPU is actively serving a user request. Configurable dream window; all operations logged to an expandable dream journal in the Activity tab. Manual 🌙 Dream button in the Knowledge graph panel.

Details →

Uploaded documents are processed through a map-reduce LLM pipeline that extracts structured knowledge into the graph. Documents are split into windows, summarized, then reduced into a coherent article; core entities and relations are extracted with full source provenance. A curated relation vocabulary (67 types + 60 aliases) eliminates unknown-type warnings; entity caps (12 per document), minimum description length (30 chars), hub entity dedup, and self-loop rejection ensure clean output. Supports PDF, DOCX, TXT, Markdown, HTML, and EPUB. Live progress pill in the status bar with phase indicator and stop button. Per-document cleanup removes vector store entries and all extracted entities.

Details →

Run fully local via Ollama (39 curated tool-calling models) or connect cloud providers — OpenAI, Anthropic (Claude), Google AI (Gemini), xAI (Grok), and OpenRouter (100+ models) — switchable per-thread and per-task from the GUI. First-launch wizard offers Local or Cloud paths; star favorites for quick access; cloud vision models are auto-detected. Privacy controls disable memory extraction and auto-recall for cloud threads. Smart context trimming reduces token usage and cloud API costs.

Details →

Toggle-based voice input with local faster-whisper STT (4 model sizes, CPU-only int8) — no cloud APIs. Neural TTS via Kokoro with 10 voices (US/British, male/female), streaming sentence-by-sentence with automatic mic gating during playback. Combine both for a fully hands-free conversational experience.

Details →

Full shell access with 3-tier safety — safe commands (ls, git status) auto-execute, moderate commands (rm, pip install) require confirmation, dangerous commands (shutdown, reboot, mkfs) are blocked outright. Enhanced destructive-command detection for workflow safety-mode integration. Persistent sessions per thread, inline terminal panel, command history saved to disk. Background tasks and workflows support per-task command prefix allowlists.

Details →

Autonomous browsing in a visible Chromium window — navigate, click, type, scroll, and manage tabs through natural conversation. Accessibility-tree snapshots with numbered element references; per-thread tab isolation; persistent login profile; smart snapshot compression for context efficiency; crash recovery and automatic browser detection (Chrome → Edge → Playwright).

Details →

Camera capture, screen capture, and workspace image file analysis via local or cloud vision models. Cloud models with vision capability (GPT-4o, Claude) are auto-detected. Images displayed inline in chat; configurable vision model selection.

Details →

Advanced workflow engine powered by APScheduler with 7 schedule types (daily, weekly, weekdays, weekends, interval, cron, one-shot delay) and a full step-based pipeline builder. Five step types — Prompt, Condition, Approval, Subtask, and Notify — with conditional if_true/if_false branching, approval gates that pause for human decisions, webhook triggers, task-completion triggers, concurrency groups, and per-workflow safety mode (block destructive, require approval, or allow all). Template variables ({{date}}, {{time}}, {{step.X.output}}), channel delivery (Telegram/Email), per-task model override, and configurable background permissions. A redesigned workflow builder UI offers simple and advanced modes with a visual Mermaid flow preview. Pending approvals surface in the sidebar with badge counts and quick-approve buttons.

Details →

A generic Channel ABC lets any messaging platform plug into Thoth — channels declare capabilities (photo, voice, documents, reactions, buttons, streaming) and the system auto-generates tools, settings UI, and health checks for each one. Five channels ship out of the box:

• Telegram — inbound voice transcription (faster-whisper), photo analysis (Vision), document handling with text extraction (PDF/CSV/JSON), emoji reactions (👀/👍/💔), inline keyboard buttons for approvals, streaming responses via progressive message edits
• WhatsApp — Node.js bridge (Baileys) with QR-code pairing; inbound/outbound text, photos, documents, and voice; YouTube rich link previews; Markdown-to-WhatsApp formatting; streaming via message edits
• Discord — discord.py adapter with DM-based messaging; streaming, reactions, typing indicators, slash commands, and media support
• Slack — slack-bolt adapter with Socket Mode (no webhook needed); DM threading; streaming via chat.update; reactions, typing, and file uploads
• SMS — Twilio adapter with inbound webhook; outbound via REST API; MMS photo support; auto-tunnel for inbound delivery

All channels share auth utilities, slash commands, approval routing, corrupt-thread repair, and media capture helpers. A tunnel manager (ngrok) auto-exposes webhook ports for channels that need inbound delivery. A live channel monitor in the sidebar shows status dots, icons, and last-activity times for all configured channels.

Details →

Generate and edit images via OpenAI, xAI (Grok Imagine), and Google (Imagen 4, Nano Banana) — rendered inline in chat, persisted to disk, and deliverable to any messaging channel. Supports OpenAI (gpt-image-1, gpt-image-1.5, gpt-image-1-mini), xAI (grok-imagine-image), and Google (imagen-4.0-generate-001, Gemini image models) with configurable size and quality. Edit existing images by referencing the last generation, a pasted attachment, or a file path. Per-provider model picker in Settings → Models.

Details →

A sandboxed, hot-reloadable plugin architecture lets anyone add new tools and skills without touching core code. Plugins declare metadata in plugin.json, are security-scanned (no eval/exec/subprocess), and run in a dependency-safe sandbox. A built-in marketplace lets users browse, install, update, and uninstall plugins from a curated GitHub-hosted catalog. Plugin settings, API keys, enable/disable toggles, and per-plugin config dialogs are all managed from Settings → Plugins.

Details →

Conversational tracking for medications, symptoms, exercise, periods, mood, sleep — "I took my Lexapro", "Headache level 6". Auto-detection with confirmation; 7 built-in analyses (adherence, streaks, numeric stats, trends, co-occurrence, cycle estimation); CSV export chains to Plotly charts. All data in local SQLite, excluded from the memory system.

Details →

Native window via pywebview with system tray, splash screen, right-click context menu, and auto-restart. First-launch setup wizard (Local or Cloud). Self-contained one-click installers for Windows (Inno Setup) and macOS (.app with code signing + notarization) — CI/CD pipeline automates builds, signing, and GitHub Releases.

Details →

Multi-turn threads with LangGraph checkpointer, auto-naming, per-thread model switching, and export (Markdown, text, PDF via Playwright). Attach images, PDFs, CSV, Excel, JSON — plus clipboard paste and drag-and-drop. File-on-disk media storage with two-tier persistence — generated content survives thread deletion, transient captures cleaned up automatically. Auto-scroll follows streaming output with user-override (scroll up to pause, new message re-engages). Inline rendering: Plotly charts, Mermaid diagrams (flowchart, sequence, state, ER, Gantt, mindmap), YouTube embeds (including Shorts), and syntax-highlighted code. Modern chat input with rounded card layout and inline file chips. Status monitor panel with animated avatar, health-check pills, OAuth token monitoring, and one-click diagnosis. Sidebar channel monitor with live status dots, icons, and last-activity tracking for all configured channels. Streaming robustness improvements replace silent failures with debug logging; output truncation detection warns when the model hits its token limit.

Details →

Desktop notifications, distinct audio chimes (task completion, timer alerts), and contextual in-app toasts — success auto-dismisses, errors persist as red banners. Unified notify() call across all channels.

Details →

10 reusable instruction packs plus 13 tool guides injected into the system prompt when enabled — each a SKILL.md with YAML frontmatter. Manual skills toggle from Settings; tool guides auto-activate when their linked tools are enabled. Create custom skills via the in-app editor or ~/.thoth/skills/.

Details →

OpenClaw is the most popular open-source personal AI assistant (~350k stars). It's a powerful multi-channel gateway built for developers comfortable in the terminal. Here's how the two compare:

In short: OpenClaw is a powerful gateway for developers who want their AI assistant on every messaging platform. Thoth is built for people who want personal AI sovereignty — local-first intelligence, a structured knowledge graph that grows with you, one-click setup, and tools that work without touching a terminal. Different philosophies, both open source.

For comparisons with ChatGPT and other cloud assistants, see docs/ARCHITECTURE.md.

Thoth's agent has access to 25 tools that expose 79 individual operations to the model. Tools can be enabled/disabled from the Settings panel.

• Destructive operations require confirmation: workspace_file_delete, workspace_move_file, run_command (moderate-risk), send_gmail_message, move_calendar_event, delete_calendar_event, delete_memory, tracker_delete, task_delete
• Filesystem is sandboxed: only the configured workspace folder is accessible (defaults to ~/Documents/Thoth, auto-created on first use)
• Shell commands are safety-classified: safe (auto), moderate (confirm), blocked (rejected); high-risk commands like shutdown, reboot, mkfs are blocked outright; moderate commands in background tasks require per-task command prefix allowlists
• Browser tabs are isolated per thread: each chat or background task gets its own browser tab; tabs are cleaned up on task completion or thread deletion
• Background task permissions are configurable per-task: shell command prefixes and email recipients can be allowlisted in the task editor
• Gmail/Calendar operations are tiered: read, compose/write, and destructive tiers can be toggled independently
• Prompt-injection defence — 5-layer scanning protects against injection attacks in tool outputs and user inputs: instruction override detection, role impersonation, data exfiltration, encoding evasion, and social engineering patterns
• Tools can be individually disabled from Settings to reduce model decision complexity

┌──────────────────────────────────────────────────────────────────────┐
│                    NiceGUI Frontend (app.py + ui/ package)              │
│  ┌────────────┐  ┌──────────────────────┐  ┌───────────────────┐   │
│  │  Sidebar   │  │   Chat Interface     │  │   Settings Dialog │   │
│  │  Threads   │  │   Streaming Tokens   │  │   13 Tabs         │   │
│  │  Controls  │  │   Tool Status        │  │   Tool Config     │   │
│  │ Knowledge  │  │ Knowledge Graph View │  │   Cloud Settings  │   │
│  │ Approvals  │  │   Approval Gates     │  │                   │   │
│  └────────────┘  └──────────────────────┘  └───────────────────┘   │
│  ┌──────────────────────────────────────────────────────────────┐   │
│  │  Status Monitor — Avatar · 17 Health Pills · Diagnosis Btn  │   │
│  └──────────────────────────────────────────────────────────────┘   │
└──────────────────────────┬───────────────────────────────────────────┘
                           │
                           ▼
┌──────────────────────────────────────────────────────────────────────┐
│               LangGraph ReAct Agent (agent.py)                       │
│                                                                      │
│   create_react_agent() with pre-model message trimming              │
│   System prompt with TOOL USE, MEMORY, and CITATION guidelines      │
│   Interrupt mechanism for destructive action confirmation            │
│   Graph-enhanced auto-recall (semantic + 1-hop expansion)           │
│   Per-thread model override (local or cloud)                        │
│                                                                      │
│   79 LangChain sub-tools from 25 registered tool modules            │
│   + plugin tools + auto-generated channel tools                     │
└───────┬──────────┬──────────┬──────────┬──────────┬─────────────────┘
        │          │          │          │          │
        ▼          ▼          ▼          ▼          ▼
  ┌──────────┐ ┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐
  │   LLMs   │ │Knowledge│ │ SQLite │ │ FAISS  │ │External│
  │  Ollama  │ │ Graph  │ │Threads │ │ Vector │ │  APIs  │
  │ + Cloud  │ │(SQLite+│ │(local) │ │ Store  │ │(opt-in)│
  │ (opt-in) │ │NetworkX)│ │        │ │        │ │        │
  └──────────┘ └────────┘ └────────┘ └────────┘ └────────┘

📖 Module descriptions, data storage layout, and full system internals → docs/ARCHITECTURE.md

Note: The default local model (qwen3:14b, ~9 GB) runs well on CPU with 16 GB RAM, but a GPU makes responses significantly faster. Smaller models like qwen3:8b (~5 GB) work on 8 GB RAM machines.

You still need an API key from OpenAI, Anthropic, Google AI, xAI, or OpenRouter. Cloud models are billed per-token by the provider — typically pennies per conversation.

1. Download ThothSetup_3.15.0.exe from the latest release
2. Run the installer — it installs Python, Ollama, and all dependencies automatically
3. Launch Thoth from the Start Menu or Desktop shortcut

1. Download Thoth-3.15.0-macOS-arm64.dmg from the latest release
2. Open the DMG and drag Thoth.app into the Applications folder
3. Launch Thoth from Applications or Launchpad
   • First run may prompt "Thoth is an app downloaded from the internet" → click Open
   • First run installs Homebrew (if needed), Python, Ollama, and all dependencies automatically
   • Subsequent launches skip installation and start in ~3 seconds

Works on Apple Silicon (M1/M2/M3/M4) and Intel Macs (macOS 12+). No terminal, no manual setup — just double-click and go.

Using cloud models only? The installer still sets up Ollama by default, but you can skip model downloads. On first launch, choose the Cloud setup path, enter your API key, and start chatting — no GPU required.

Prefer a manual install? A few commands from source:

1. Install Ollama (required for local models — skip if using cloud models only)

2. Clone the repository

   git clone https://github.com/siddsachar/Thoth.git
   cd Thoth

3. Create and activate a virtual environment

   python -m venv .venv
   # Windows
   .venv\Scripts\activate
   # macOS / Linux
   source .venv/bin/activate

4. Install dependencies

   pip install -r requirements.txt

5. Start Ollama (if using local models)

   ollama serve

6. Launch Thoth

   python launcher.py

   This starts the system tray icon and opens the app at http://localhost:8080.

   Alternatively, run directly without the tray:

   python app.py

First launch: A setup wizard lets you choose between Local (Ollama) and Cloud (API key) setup paths. For local, the default brain model (qwen3:14b, ~9 GB) is recommended. For cloud, enter your API key (OpenAI, Anthropic, Google AI, xAI, or OpenRouter) and pick a default model.

Most tools work without any API keys. For cloud models and enhanced functionality:

Configure cloud keys in ⚙️ Settings → ☁️ Cloud tab. Keys are stored locally in ~/.thoth/cloud_config.json — never sent to Thoth's servers (there are none).

Configure channel keys in ⚙️ Settings → 📡 Channels and ⚙️ Settings → 🔗 Accounts tabs. Keys are stored locally.

For Gmail and Google Calendar, you'll need a Google Cloud OAuth credentials.json — setup instructions are provided in the respective Settings tabs.

1. Launch Thoth and wait for the default model to download (first time only)
2. Click "＋ New conversation" in the sidebar
3. Ask anything — the agent will automatically choose which tools to use:
   • "What's the weather in Tokyo?" → uses Weather tool
   • "Search for recent papers on transformer architectures" → uses Arxiv
   • "Remember that my mom's birthday is March 15" → saves to Memory
   • "Read the file report.pdf in my workspace" → uses Filesystem
   • "Run git status on my project" → uses Shell (safe, auto-executes)
   • "Install pandas with pip" → uses Shell (moderate, asks for approval)
   • "What's on my screen right now?" → uses Vision (screen capture)
   • "I took my Lexapro" → asks to log, then saves to Tracker
   • "Show my headache trends this month" → uses Tracker + Chart
   • "Remind me to call the dentist tomorrow at 9am" → uses Tasks with scheduling
   • "What did I ask about taxes last week?" → uses Conversation Search
4. Open ⚙️ Settings to configure models, enable/disable tools, and set up integrations

1. Launch Thoth → on the setup wizard, choose ☁️ Cloud
2. Enter your API key (OpenAI, Anthropic, Google AI, xAI, or OpenRouter) → Thoth validates and fetches available models
3. Pick a default model (e.g. GPT) and start chatting — no downloads, no GPU needed
4. Switch models per conversation anytime from the chat header dropdown

Local models (default): All LLM inference runs on your machine via Ollama. Documents, memories, and conversations stored locally in ~/.thoth/. External network calls only when using online tools (web search, Gmail, Calendar) — each individually disableable. No telemetry, no tracking.

Cloud models (opt-in): Only the current conversation is sent to the LLM provider (OpenAI, Anthropic, Google AI, xAI, or OpenRouter). Memories, knowledge graph, documents, files, and other conversations never leave your machine. Your API key connects directly to the provider — Thoth has no servers and no middleman.

Always: API keys stored locally; no Thoth account required; no sign-up; no server to phone home to. Tools can be individually disabled to control what the agent can access.

Apache 2.0 — see LICENSE for details.

Built with NiceGUI, LangGraph, LangChain, Ollama, FAISS, Kokoro TTS, faster-whisper, HuggingFace, and tiktoken.