ARCHIVE_Technical Specification_Old - asavschaeffer/globule GitHub Wiki
Globule is not another note-taking app. It's the first step toward a semantic operating system where computers understand the meaning and connections between all user activities, not just the mechanical facts of what happened.
Core Innovation: Every input is captured, understood semantically, and becomes queryable through natural language - no files, folders, or manual organization required.
MVP Goal: Prove that semantic capture and retrieval can replace traditional file management, starting with a focused use case (operational note-taking) that demonstrates the broader paradigm shift.
- We name files like
meeting-notes-2024-07-03-jones-damage-FINAL-v2.txt
- We organize information in rigid hierarchies that don't match how we think
- We lose thoughts because the friction of proper organization breaks our flow
- Our computers know WHAT we did but not WHY or HOW things connect
$ globule ask "what was that thing about Jones and the damage?"
> Found 3 connected events from July 3:
> - 9:15 AM: "Mr Jones arrived, noticed existing fender damage"
> - 2:30 PM: "Jones claiming new damage, but we documented it this morning"
> - 2:45 PM: Photo evidence saved showing pre-existing damage
Goal: Demonstrate that semantic search beats folders/files
Components:
# Minimal data structure
class Globule:
id: str
content: str
timestamp: datetime
embedding: List[float] # 384-dim from sentence-transformers
Core operations
capture(text: str) -> Globule
search(query: str) -> List[Globule]
Storage: SQLite with vector extension
- Single file database
- JSON column for metadata
- Vector column for embeddings
- Full-text search as fallback
Interface: Simple CLI
$ globule add "Mr Jones arrived with damaged fender"
$ globule search "damage claims today"
$ globule ask "what happened with parking?"
Goal: Show that AI can extract structure without schemas
Addition:
class SmartGlobule(Globule):
entities: List[str] # ["mr_jones", "fender"]
event_type: str # "damage_report"
extracted_data: Dict # LLM-parsed fields
Key Innovation: Dual-track processing
- Embeddings capture semantic meaning
- LLM parsing extracts structure
- They cross-validate each other (checks & balances)
Goal: Transform from "storage" to "understanding"
Query Engine:
- Natural language → structured search
- Temporal queries: "what happened this morning?"
- Entity queries: "everything about Jones"
- Pattern queries: "unusual events today"
Synthesis Engine:
- Combine related globules into narratives
- Generate reports/summaries on demand
- Surface patterns and anomalies
Component | Technology | Why |
---|---|---|
Storage | SQLite + vector extension | Single file, portable, fast |
Embeddings | sentence-transformers/all-MiniLM-L6-v2 | Proven, CPU-friendly, 384-dim |
LLM Parsing | Local: Llama 3.2 3B / Cloud: Gemini | Start local, scale to cloud |
Interface | CLI → TUI (Textual) → API | Progressive enhancement |
Input → Parallel Processing → Storage → Retrieval → Synthesis
├─ Embedding ──────────┐
└─ LLM Parsing ────────┴──→ Validation
This isn't the product - it's the proof that the paradigm works.
Throughout the day:
$ globule add "Mrs Chen's Tesla parked in B5"
$ globule add "Timmy arrived 20 min late"
$ globule voice "damage on Jones car already there when he arrived"
$ globule add "split tips 60 total between timmy barbara and me"
End of shift:
$ globule report today
> Generated comprehensive summary...
> Key incidents: Pre-existing damage documented (Jones)
> Staff: Timmy late (20min), Tips distributed ($20 each)
> Recommendations: Document Timmy's pattern (3x this week)
Level 1 (MVP): Manual input → Semantic retrieval Level 2: Passive monitoring
- File system events
- Git commits
- Browser history
- Clipboard monitoring
Level 3: Full semantic layer
- All computer operations are semantically tagged
- Natural language queries across all activity
- Time travel through your digital life
$ globule ask "what was I doing when the server crashed?"
> You were editing auth_handler.py (JWT validation)
> Had 4 Stack Overflow tabs about "bearer token expiry"
> pytest failed 6 times on auth tests
> Last successful test was before changing line 47
-
Capture First, Organize Never: Users just dump thoughts. AI handles organization.
-
Semantic > Hierarchical: Information is connected by meaning, not folders.
-
Progressive Disclosure: Start simple (text input), add capabilities without complexity.
-
Privacy First: Local by default, cloud by choice.
-
Domain Agnostic: Core system works for any use case, domains are just configurations.
- Sub-100ms capture latency
- Semantic search finds relevant content traditional search misses
- <5s to generate daily synthesis
- Zero organization effort required
- Find any thought within 3 seconds
- Discover 1+ unexpected connection per day
- Daily active usage after 1 week
- 50%+ reduction in time spent organizing
- Users report feeling "understood" by their computer
- Week 1: Implement core capture + embedding + search
- Week 2: Add temporal queries and basic CLI
- Week 3: Integrate LLM parsing
- Week 4: Build synthesis engine
- Week 5: Polish and demo creation
- Week 6: User testing with 3 personas
Q: How is this different from Apple Intelligence or Copilot? A: Those are closed ecosystems. Globule is open, private by default, and works with any tool.
Q: Why not just use ChatGPT? A: ChatGPT doesn't remember between sessions. Globule builds a persistent semantic layer of YOUR life.
Q: What about privacy? A: Everything stays local by default. Cloud features are opt-in and encrypted.
Q: Can it integrate with existing tools? A: Yes. Phase 2 adds APIs and webhooks. ActivityWatch, git, browsers, etc.
We're not building another app. We're prototyping the future of human-computer interaction - where your computer understands context and meaning, not just commands and files.
Give us 6 weeks to prove that files and folders are obsolete.
"The best way to predict the future is to invent it." - Alan Kay