Rowboat: Open-Source AI Coworker That Turns Your Work Into a Knowledge Graph

⬅️ Back to Tools

Rowboat: Your Private AI Work Partner

Rowboat is an open-source AI coworker that fundamentally changes how you manage information and get work done. Unlike cloud-based AI assistants that send your data to remote servers, Rowboat runs entirely on your machine, ingests your email and meeting notes, builds a persistent knowledge graph, and uses that rich context to help you accomplish tasks—from prepping for meetings to generating entire presentations.

Think of it as having a brilliant colleague who remembers every conversation, decision, and detail, and can instantly synthesize that knowledge into actionable outputs. All while keeping your data locked down on your own hardware.

Key Features

📧 Email and Meeting Integration

Rowboat connects to your existing workflows:

• Email Ingestion: Automatically processes your email threads, extracting key information, decisions, and action items
• Meeting Notes: Connects to meeting platforms or note-taking apps to capture discussions and outcomes
• Continuous Learning: Builds and updates your knowledge graph over time as new information flows in

The system doesn’t just store raw data—it understands relationships, context, and relevance.

🧠 Long-Lived Knowledge Graph

At the heart of Rowboat is a knowledge graph that persists across sessions:

• Markdown-Based: Your knowledge graph is stored as plain Markdown files that you can view, edit, and version control
• Relationship Mapping: Understands connections between people, projects, decisions, and timelines
• Context Preservation: Maintains institutional knowledge even as team members change or projects evolve
• Transparent Structure: Unlike black-box AI systems, you can see exactly what Rowboat knows and how it’s organized

This isn’t just a search index—it’s a living representation of your work context.

🤖 AI-Powered Actions

Once Rowboat understands your work, it can help you act on it:

Generate Documents

Example: “Build me a deck about our next quarter roadmap”

Rowboat will:

• Pull relevant context from your knowledge graph
• Identify past decisions and commitments
• Find related discussions and constraints
• Generate a structured PDF presentation
• Include citations back to source materials

Meeting Preparation

Example: “Prep me for my meeting with Alex”

Rowboat creates a comprehensive brief including:

• Past decisions and agreements with Alex
• Open questions or unresolved items
• Relevant threads and conversations
• Recent updates that might impact the discussion
• Delivered as text or voice memo

Voice Memo Processing

Record voice memos that automatically:

• Transcribe your thoughts
• Extract key takeaways
• Update relevant sections of your knowledge graph
• Link to related projects or people
• Create actionable items

🔒 Privacy-First Architecture

Rowboat’s most important feature is its commitment to privacy:

• Local Processing: All AI inference runs on your machine
• No Data Sharing: Your emails, meetings, and knowledge never leave your computer
• Self-Hosted: You control the infrastructure and data storage
• Open Source: Audit the code to verify privacy claims
• Bring Your Own LLM: Use local models (Ollama, LM Studio) or your own API keys

In an era where every AI tool wants to hoard your data, Rowboat takes the opposite approach: your work context stays yours.

How It Works

1. Data Ingestion

Rowboat connects to your data sources through secure integrations:

Email → Rowboat → Knowledge Extraction
Meeting Notes → Rowboat → Entity Recognition
Voice Memos → Rowboat → Transcription + Analysis

2. Knowledge Graph Construction

The system processes ingested data to build a structured graph:

• Entities: People, projects, companies, deadlines
• Relationships: Works with, decided, blocked by, depends on
• Events: Meetings, milestones, deliverables
• Content: Decisions, action items, open questions

3. Query and Action

When you ask Rowboat to do something, it:

1. Understands Intent: Parses your natural language request
2. Retrieves Context: Queries the knowledge graph for relevant information
3. Synthesizes: Combines multiple data points into coherent outputs
4. Generates: Creates documents, briefs, or voice memos
5. Updates Graph: Records new information back into the knowledge graph

Getting Started

Prerequisites

• Python 3.8+
• Node.js 16+
• Git
• LLM access (local via Ollama/LM Studio, or API keys for OpenAI/Anthropic)

Installation

# Clone the repository
git clone https://github.com/rowboatlabs/rowboat.git
cd rowboat

# Install dependencies
pip install -r requirements.txt
npm install

# Configure your LLM provider
cp config.example.yaml config.yaml
# Edit config.yaml with your LLM settings

# Run Rowboat
python main.py

Configuration

Edit config.yaml to set up:

• LLM Provider: Choose between local (Ollama) or cloud (OpenAI, Anthropic)
• Email Integration: Connect IMAP/SMTP or Gmail API
• Meeting Sources: Notion, Obsidian, or file system
• Knowledge Graph Storage: Local directory path

First Run

1. Initial Ingestion: Rowboat will process your configured data sources
2. Graph Building: This may take time depending on data volume
3. Verification: Check the generated Markdown files to see your knowledge graph
4. First Query: Try “What are my open action items?” to test functionality

Use Cases

For Executives

• Weekly Prep: “Summarize my week and flag urgent items”
• Board Decks: “Create Q4 board presentation from recent decisions”
• 1:1 Preparation: “What should I discuss with my direct reports?”

For Product Managers

• Feature Context: “What user feedback relates to the search feature?”
• Stakeholder Updates: “Draft a product update for leadership”
• Meeting Follow-ups: “Send follow-up emails from yesterday’s meetings”

For Consultants

• Client Context: “Prep me for the Acme Corp call”
• Project Synthesis: “Extract all deliverables from the past month”
• Knowledge Transfer: “Document what I’ve learned on this engagement”

For Teams

• Shared Context: Build a team knowledge base from collective communications
• Onboarding: New team members can query historical decisions
• Handoffs: Preserve project context when people change roles

Architecture Overview

┌─────────────────┐
│   Data Sources  │
│  (Email, Notes) │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Ingestion &    │
│  Processing     │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│ Knowledge Graph │
│   (Markdown)    │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│ Query & Action  │
│   (LLM Layer)   │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│   Outputs       │
│ (Docs, Briefs)  │
└─────────────────┘

Privacy and Security Considerations

Data Locality

• All processing happens on your machine
• No telemetry or analytics sent to Rowboat Labs
• Knowledge graph is plain Markdown—easily auditable
• Optional encryption at rest for sensitive graphs

API Key Management

• Store API keys in environment variables, never in code
• Support for key rotation
• Optional: Use local LLMs to avoid API keys entirely

Access Control

• File system permissions control who can read your knowledge graph
• No authentication server—your OS handles access
• Easy to backup and version control your data

Comparison with Other Tools

Choose Rowboat if: Privacy is paramount, you want persistent knowledge across sessions, and you need deep integration with your existing work tools.

Choose others if: You prefer managed solutions, don’t need persistent context, or want the simplest possible setup.

Tips for Best Results

1. Start Small: Begin with one data source (email or notes) to see how Rowboat structures information

2. Review Your Graph: Regularly look at the generated Markdown files to understand what’s being captured

3. Be Specific: When asking Rowboat to do something, specific requests yield better results than vague ones

4. Tag Important Items: Use consistent naming conventions in your source data to improve entity recognition

5. Maintain Your Graph: Periodically clean up outdated information to keep the knowledge graph relevant

6. Use Voice Memos: They’re the fastest way to capture thoughts that should enter your knowledge graph

7. Iterate on Prompts: If the output isn’t quite right, refine your request and try again

Limitations and Considerations

• Setup Complexity: Requires technical knowledge to install and configure
• Initial Ingestion Time: Processing years of email can take hours
• LLM Costs: If using cloud LLMs, costs scale with usage (local models are free but slower)
• Accuracy: AI extraction isn’t perfect—important decisions should be verified
• Maintenance: You own the infrastructure, which means you handle updates and troubleshooting

References

• 🔗 GitHub Repository: https://github.com/rowboatlabs/rowboat
• 🔗 Rowboat Labs: https://rowboatlabs.com (if available)
• 🔗 Documentation: Check the repo’s README and docs/ folder

Related Technologies:

• Ollama: For running local LLMs
• LM Studio: Alternative local LLM interface
• Obsidian: Popular Markdown-based note-taking that pairs well with Rowboat
• Notion: Can serve as a meeting notes source

Similar Concepts:

• Personal Knowledge Management (PKM): Tools like Roam Research, Obsidian, Logseq
• AI Assistants: But with persistent memory and local processing
• Second Brain: The broader concept of externalizing cognitive load

Why This Tool Rocks

• Privacy by Design: Your data never leaves your machine—period
• Persistent Memory: Unlike chat-based AI, Rowboat remembers everything across sessions
• Actionable Output: Doesn’t just retrieve information; helps you create deliverables
• Open Source: Fully auditable, community-improvable, no vendor lock-in
• Markdown-Based: Your knowledge graph is portable, future-proof, and human-readable
• Voice-First Options: Capture thoughts in the moment without typing
• Contextual Intelligence: Understands relationships between people, projects, and timelines
• Bring Your Own AI: Use local models for zero cost or cloud models for speed—your choice

In a world of AI tools that want to own your data, Rowboat represents a different philosophy: AI should amplify your capabilities while keeping you in complete control of your information.

Crepi il lupo! 🐺