Mycelica

Knowledge organization that mirrors how you actually think

Import conversations, papers, code — get navigable hierarchy with semantic edges and certainty scoring. No manual tagging. Structure emerges from content.

Named after mycelium, the underground fungal network that connects forests without central control.

aaaaamycelica.mp4

---

Try It Now

53,167 research papers. 170,824 semantic connections. Zero setup.

1. Download latest release
2. Grab mycelica-consciousness-demo.db (800 MB)
3. Open Mycelica → Settings → Info → Open database
4. Navigate (first launch builds similarity index ~40s, then instant)

Imported from OpenAIRE — consciousness research spanning neuroscience, philosophy of mind, clinical applications, and meditation studies.

8-level hierarchy with 170k semantic edges. No manual categorization. Structure emerged from embeddings.

---

Why

Knowledge tools mimic file systems: folders, hierarchies, categories. But thinking is both hierarchical and associative — and current tools only show one or the other.

Every insight links to others. Every question branches into more questions. Every concept echoes across domains. Traditional tools bury these connections in separate folders, separate apps, separate contexts.

Mycelica shows structure you can navigate, plus connections that cross category boundaries. Reasoning becomes visible. Your knowledge becomes a living network you can explore, not a graveyard of files you'll never reopen.

Features

• Visual Graph Navigation — Zoomable, pannable D3 canvas with dynamic hierarchy levels
• AI-Powered Analysis — Claude/Ollama generates titles, summaries, and tags for imported content
• Adaptive Hierarchy — Edge-based algorithm builds navigable tree structure from semantic similarity
  • Items automatically organized into categories based on embedding similarity
  • No manual categorization required - structure emerges from the data
• Instant Similarity Search — HNSW index enables O(log n) nearest neighbor lookup:
  • 50-100x faster than brute-force (~10ms vs ~870ms for 50k nodes)
  • Index auto-builds on first launch, saved to disk for instant subsequent loads
  • Local embeddings (all-MiniLM-L6-v2) create "Related" edges:

  "Rust async debugging"    ←─ 0.89 ─→  "Tokio runtime errors"
  "Consciousness research"  ←─ 0.76 ─→  "Philosophy of mind"
  

• Code Import — Import source code with function/class extraction and call graph analysis:
  • Supports Rust, Python, TypeScript, JavaScript, C, Markdown, RST documentation
  • Calls edges show function call relationships
  • Semantic search across your codebase
  • Note: Export formats (BibTeX, JSON, Markdown, DOT) are CLI-only
• Browser Integration — Holerabbit Firefox extension tracks browsing sessions:
  • Automatic session grouping with navigation edges
  • Pause/resume/rename sessions from app or extension
  • Real-time sync between browser and Mycelica
• Leaf Reader — Full-screen reader for conversations (chat bubbles) and notes (markdown)
• Privacy Filtering — Showcase/normal modes for safe database exports
• Import — Claude conversations, Markdown files, OpenAIRE papers, Google Keep, source code
• OpenAIRE Integration — Query EU Open Research Graph with country/field/year filters, optional PDF download
• CLI & TUI — 21 command categories, interactive terminal UI, BibTeX/JSON/Markdown/DOT export
• Local-First — SQLite database stays on your machine

---

Installation

Pre-built Binaries

Download from Releases:

Format	Install
.deb	sudo dpkg -i Mycelica_*.deb
.rpm	sudo rpm -i Mycelica-*.rpm
.AppImage	chmod +x Mycelica_*.AppImage && ./Mycelica_*.AppImage
.tar.gz (CPU)	tar -xzf mycelica-cli-*.tar.gz — CLI only
.tar.gz (CUDA)	tar -xzf mycelica-cli-cuda-*.tar.gz — CLI with GPU acceleration
Arch Linux	yay -S mycelica-bin — prebuilt, or yay -S mycelica — build from source

Build from Source

# Prerequisites: Rust toolchain, Node.js 18+, platform build tools

git clone https://github.com/Ekats/Mycelica.git
cd Mycelica
npm install
npm run tauri dev    # Development
npm run tauri build  # Production

API Keys & LLM Backend

Set via Settings panel or environment variables:

Key	Required	Purpose
ANTHROPIC_API_KEY	Yes*	AI analysis (titles, summaries, tags), category naming

*Or use Ollama as a local alternative (Settings → API Keys → toggle Claude/Ollama). Embeddings, clustering, and hierarchy structure are always local — no API needed for those.

---

CLI & TUI

Mycelica includes a headless CLI for scripting, automation, and server use.

Build the CLI

cd src-tauri

# Install globally with CUDA (recommended, requires nightly)
cargo +nightly install --path . --bin mycelica-cli --features cuda --force

# Copy to sidecar location (required for GUI to spawn CLI)
cp ~/.cargo/bin/mycelica-cli binaries/mycelica-cli-x86_64-unknown-linux-gnu

# CPU-only build (no nightly required)
cargo build --release --bin mycelica-cli

The sidecar copy is required for GUI buttons like "Full Setup" and "Build Hierarchy" which spawn the CLI internally.

CLI Usage

Quick Start

mycelica-cli tui                # Interactive terminal UI
mycelica-cli search "query"     # Global search
mycelica-cli import openaire -q "neural" --max 500
mycelica-cli setup              # First-time wizard (for processing imports)
mycelica-cli export bibtex -o papers.bib

mycelica-cli [OPTIONS] <COMMAND>

# Global options
--db <PATH>     # Use specific database
--json          # Output JSON for scripting
-q, --quiet     # Suppress progress output
-v, --verbose   # Detailed logging

Commands

**Top-level:**

Command	Description
setup	Interactive first-time setup wizard
tui	Interactive TUI mode
search <query>	Global search across all nodes
db	Database operations
import	Import data
export	Export data
node	Node operations
hierarchy	Hierarchy operations
process	AI processing
embeddings	Embedding operations
privacy	Privacy analysis
paper	Paper operations
config	Configuration
recent	Recent nodes
pinned	Pinned nodes
nav	Graph navigation
maintenance	Database maintenance
completions	Shell completions
analyze	Code analysis (call graph)
code	Code operations (show source)

**Import subcommands:**

Command	Description
import openaire -q "..."	Import from OpenAIRE
import claude <file>	Import Claude JSON
import chatgpt <file>	Import ChatGPT JSON
import markdown <path>	Import Markdown
import keep <zip>	Import Google Keep
import code <path>	Import source code (Rust, Python, TS, C)

**Export subcommands:**

Command	Description
export bibtex -o file.bib	BibTeX format
export markdown -o file.md	Markdown format
export json -o file.json	JSON format
export graph -o file.dot	DOT graph
export subgraph <id>	Export subtree

OpenAIRE import options

Option	Description
-q, --query	Search query (required)
-c, --country	Country code (EE, US, etc.)
--fos	Field of science
--from-year	Start year
--to-year	End year
-m, --max	Max papers [default: 100]
--download-pdfs	Download PDFs
--max-pdf-size	Max PDF MB [default: 20]

Examples

# First-time setup wizard
mycelica-cli setup

# Interactive database picker
mycelica-cli db select

# Import papers from OpenAIRE
mycelica-cli import openaire --query "machine learning" --country EE --max 500

# Import with PDF download
mycelica-cli import openaire --query "neural" --download-pdfs --max-pdf-size 10

# Global search
mycelica-cli search "interoception" --limit 20

# Export as BibTeX
mycelica-cli export bibtex -o ~/papers.bib

# JSON output for scripting
mycelica-cli --json search "neural" | jq '.[].title'

# Launch TUI
mycelica-cli tui

# Generate shell completions
mycelica-cli completions bash >> ~/.bashrc

TUI Mode

Interactive terminal UI with 3-column layout:

mycelica-cli tui

Layout: Tree (50%) | Pins + Recents (25%) | Preview (25%)

**Hierarchy Navigation:**

Key	Action
j/k	Navigate up/down
Enter	Enter cluster / open item
Backspace / -	Go up one level
Tab	Cycle panes
/	Search mode
g/G	Jump to top/bottom
r	Reload
q	Quit

**Leaf View:**

Key	Action
Tab	Cycle: Content → Similar → Edges
n/N	Next/prev similar node
e	Edit mode
v	Open PDF externally
o	Open URL in browser
Backspace	Back to hierarchy

**Edit Mode:**

Key	Action
Arrow keys	Move cursor
Ctrl+S	Save
Esc	Cancel

---

Architecture

┌─────────────────────────────────────────┐
│   React Frontend                        │
│   TypeScript + D3 + Tailwind + Zustand  │
└──────────────┬──────────────────────────┘
               │ Tauri invoke()
┌──────────────▼──────────────────────────┐
│   Rust Backend                          │
│   Tauri 2 + Tokio + rusqlite            │
│   HTTP server on localhost:9876         │
└──────────────┬──────────────────────────┘
               │
┌──────────────▼──────────────────────────┐
│   SQLite Database                       │
│   Nodes + Edges + Embeddings + FTS5     │
└─────────────────────────────────────────┘
        ▲
        │ HTTP (localhost:9876)
┌───────┴─────────────────────────────────┐
│   Holerabbit Firefox Extension          │
│   Tracks browsing sessions              │
└─────────────────────────────────────────┘

---

Core Concepts

Hierarchy

Universe (root)
└── Categories (dynamic depth)
    └── Topics
        └── Items (imported content)

• Universe — Single root node, always exists
• Categories/Topics — Groupings created by adaptive tree algorithm, named by AI
• Items — Importable content, click to open in full-screen reader

Processing Pipeline (Conceptual Overview)

1. Import — Claude conversations, Markdown, OpenAIRE papers, Google Keep, or source code
2. AI Analysis — Generate titles, summaries, tags (code items skip this, keep function signatures)
3. Embeddings — Generate vectors locally (all-MiniLM-L6-v2)
4. Semantic Edges — Create "Related" edges between similar items
5. Hierarchy Build — Adaptive tree creates categories from edge weights (includes AI naming)
6. Similarity Index — Build HNSW index for fast nearest-neighbor lookups
7. Call Graph — Extract function call relationships (code imports only)

For exact implementation steps, run mycelica-cli setup --help or see ALGORITHMS.md.

---

Development

Project Structure

mycelica/
├── src/                    # React frontend
│   ├── components/
│   │   ├── graph/          # D3 visualization
│   │   ├── leaf/           # Content reader
│   │   ├── sidebar/        # Quick access
│   │   ├── sessions/       # Browsing sessions panel
│   │   └── settings/       # Configuration
│   ├── stores/             # Zustand state
│   └── hooks/              # Data fetching
│
├── src-tauri/              # Rust backend
│   └── src/
│       ├── commands/       # Tauri command handlers
│       ├── db/             # SQLite layer
│       ├── code/           # Source code parsers (Rust, Python, TS, C)
│       ├── ai_client.rs    # Anthropic/Ollama integration
│       ├── dendrogram.rs   # Adaptive tree algorithm
│       ├── hierarchy.rs    # Hierarchy utilities
│       ├── local_embeddings.rs  # all-MiniLM-L6-v2
│       ├── http_server.rs  # Browser extension API (port 9876)
│       └── holerabbit.rs   # Browsing session tracking

Database Locations

Environment	Path
Development	./data/mycelica.db
macOS	~/Library/Application Support/com.mycelica.app/
Linux	~/.local/share/com.mycelica.app/
Windows	%APPDATA%\Mycelica\

---

Privacy

Mycelica includes AI-powered privacy scanning:

• Normal mode — Filters health, relationships, financials, personal complaints
• Showcase mode — Strict filtering for demo databases (keeps only technical/philosophical content)

Export shareable databases with private content removed via Settings → Privacy → Export. (I suggest manual checking of nodes after filtering)

---

License

AGPL-3.0 — Copyleft. Derivatives must share source.