What Is the Purpose of the rowboatlabs/rowboat Project? A Local‑First AI Coworker

Rowboat is a local‑first AI coworker that continuously constructs a personal knowledge graph from your digital work—emails, calendar events, and meeting notes—storing everything as Obsidian‑compatible Markdown files on your machine to deliver persistent memory and contextual assistance without cloud dependencies.

The purpose of the rowboatlabs/rowboat project is to create an open‑source, privacy‑preserving AI assistant that lives entirely on your local machine. Unlike cloud‑based copilots that fetch context on demand from remote servers, Rowboat ingests your daily digital footprint—Gmail, Google Calendar, Granola notes, and more—and compiles it into a durable, queryable knowledge graph stored as plain Markdown in ~/.rowboat.

Core Architecture and Local‑First Design

Rowboat’s architecture is split into three distinct layers inside the apps/x workspace. This separation ensures that business logic remains decoupled from the Electron front‑end, enabling both headless operation and desktop integration.

Three‑Layer Workspace Structure

• Shared utilities – Found in apps/x/packages/shared/src/, this layer contains type definitions, validators, and IPC helpers used across the entire application.
• Core business logic – Located in apps/x/packages/core/src/, this layer handles knowledge‑graph synchronization, the AI assistant implementation, and the Model Context Protocol (MCP) server.
• Electron front‑end – Housed in apps/x/apps/, this layer manages the UI, preload scripts, and the main process entry point at apps/x/apps/main/src/main.ts.

Building the Knowledge Graph from Daily Work

The central purpose of Rowboat is to transform ephemeral digital activity into a persistent, linked knowledge base. This process relies on sync adapters that watch external accounts and a graph builder that enriches raw notes with semantic backlinks.

Data Ingestion via Sync Adapters

Rowboat connects to common work tools through dedicated sync modules in apps/x/packages/core/src/knowledge/:

• Gmail integration – sync_gmail.ts polls the Gmail API and writes email threads as Markdown files.
• Calendar integration – sync_calendar.ts extracts events and attendees, creating dated notes for each meeting.
• Meeting notes – granola/sync.ts imports transcripts and summaries from Granola, while similar adapters handle Fireflies and other voice memo services.

Graph Construction and Backlinking

Once raw Markdown files are written to ~/.rowboat, the graph builder at apps/x/packages/core/src/knowledge/build_graph.ts parses the content. It resolves backlinks between people, projects, and decisions, updating an in‑memory graph that the assistant queries for context.

The AI Assistant and MCP Extensibility

Rowboat’s assistant does not rely on a remote context window. Instead, it reasons over the local knowledge graph, retrieving only relevant notes before calling a language model.

Assistant Agent and Skills

The assistant implementation lives in apps/x/packages/core/src/application/assistant/agent.ts. When a user submits a request, the agent:

1. Queries the knowledge index at knowledge/knowledge_index.ts to find relevant entities.
2. Retrieves linked notes (e.g., previous decisions or open questions).
3. Invokes the LLM via application/lib/exec-tool.ts using the Vercel AI SDK or a local model (Ollama, LM Studio).

Specific skills are modularized under apps/x/packages/core/src/application/assistant/skills/. For example, meeting-prep/skill.ts generates briefings by aggregating recent threads and calendar events related to an attendee.

Model Context Protocol Integration

Rowboat exposes external tools through the Model Context Protocol (MCP) implementation in apps/x/packages/core/src/mcp/mcp.ts. This allows the assistant to invoke web search (Brave, Exa), Slack notifications, or Linear issues without hard‑coding integrations. The MCP server runs alongside the core package, enabling seamless tool use during agent execution.

Running Rowboat Locally

Because Rowboat is local‑first, all setup targets your machine. The following examples demonstrate how to launch the desktop app, connect data sources, and extend functionality.

Starting the Desktop Application

Rowboat uses an Electron front‑end built on a shared workspace. Execute the following from the repository root:

# Install workspace dependencies

cd apps/x && pnpm install

# Build shared & core packages

cd apps/x && npm run deps          # → shared → core → preload

# Launch the app in development mode

cd apps/x && npm run dev

The npm run dev script launches the Electron main process and the Vite‑powered renderer, connecting the UI to the core services defined in apps/x/apps/main/src/main.ts.

Connecting a Google Account

To ingest email and calendar data, authenticate with Google:

# Follow the guided Google OAuth flow (the UI will open a browser)

rowboat auth add google

Internally, this triggers apps/x/packages/core/src/auth/providers.ts, which creates an OAuth token and stores it under ~/.rowboat/auth/google.json. The sync adapters in sync_gmail.ts and sync_calendar.ts then begin polling.

Interacting with the AI Assistant

In the Rowboat sidebar, type natural‑language requests such as:

Prep me for my meeting with Alex tomorrow

The UI forwards the prompt to apps/x/packages/core/src/application/assistant/agent.ts, which queries the knowledge graph via knowledge/knowledge_index.ts, retrieves relevant notes (e.g., previous decisions, open questions), and calls the configured LLM through application/lib/exec-tool.ts using the Vercel AI SDK. The resulting briefing appears in the UI.

Enabling Background Agents

Automate daily workflows with scheduled agents:

rowboat agent enable daily-summary

This command registers a scheduled agent in apps/x/packages/core/src/agent-schedule/runner.ts that executes the draft‑emails skill (apps/x/packages/core/src/application/assistant/skills/draft-emails/skill.ts) each day, using current graph context to write summaries into new Markdown files in ~/.rowboat.

Extending with Custom MCP Tools

Add external capabilities by implementing the Model Context Protocol. Create a new plugin under apps/x/packages/core/src/mcp/:

// my-tool.ts
import { registerTool } from '@x/core/mcp';

registerTool('my-tool', async (input) => {
  // custom logic, e.g., call an internal API
  const result = await fetch('https://my.internal/api', { method: 'POST', body: JSON.stringify(input) });
  return result.json();
});

Then register the tool in apps/x/packages/core/src/application/assistant/skills/mcp-integration/skill.ts so the LLM can invoke my‑tool during sessions.

Summary

• Rowboat is a local‑first AI coworker that transforms daily digital activity into a persistent, queryable knowledge graph stored as Markdown in ~/.rowboat.
• The architecture separates concerns into shared utilities (apps/x/packages/shared/src/), core business logic (apps/x/packages/core/src/), and an Electron front‑end (apps/x/apps/).
• Sync adapters in sync_gmail.ts, sync_calendar.ts, and granola/sync.ts ingest external data, while build_graph.ts constructs the linked graph.
• The assistant agent (agent.ts) reasons over the local graph, retrieves context via knowledge_index.ts, and invokes LLMs through the Vercel AI SDK or local models.
• MCP integration (mcp.ts) enables external tool use without hard‑coding, supporting extensible workflows.

Frequently Asked Questions

What makes Rowboat different from other AI assistants like ChatGPT or Copilot?

Unlike cloud‑native assistants that rely on ephemeral context windows and remote servers, Rowboat operates entirely on your local machine. It maintains a persistent knowledge graph built from your actual work history—emails, meetings, and notes—stored as plain Markdown files. This design ensures privacy, offline availability, and long‑term memory that survives individual chat sessions.

How does Rowboat handle data privacy and security?

All data ingestion, storage, and processing happen locally in the ~/.rowboat directory. OAuth tokens for external services (e.g., Gmail) are stored in ~/.rowboat/auth/ and never leave your machine. The knowledge graph exists only as local Markdown files compatible with Obsidian, giving you full ownership and the ability to audit, edit, or delete any data at any time without vendor lock‑in.

Can I use Rowboat with my own local language models?

Yes. Rowboat supports both cloud LLMs via the Vercel AI SDK and local models running through Ollama or LM Studio. The assistant logic in apps/x/packages/core/src/application/assistant/agent.ts abstracts the model provider, allowing the system to query your local knowledge graph and then invoke whichever LLM endpoint you have configured, ensuring complete data sovereignty.

What types of integrations does Rowboat support?

Rowboat connects to external data sources through sync adapters (Gmail, Google Calendar, Granola, Fireflies) and exposes external capabilities via the Model Context Protocol (MCP). The MCP implementation in apps/x/packages/core/src/mcp/mcp.ts allows the assistant to call tools like Brave Search, Exa, Slack, or Linear without hard‑coded dependencies, making the system highly extensible for custom enterprise workflows.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}