BrainDrive Development Progress Updates

Help Build BrainDrive
41

Hi All,

Here is the recording from today’s dev call livestream followed by an AI powered summary of the discussion. We Livestream every Monday at 10am EST. We’d love it if you’d join us live and are also happy to address any questions, concerns, and ideas you have here in the forum. Just hit the reply button.

Thanks
Dave

Recording:

AI Powered Summary:

What BrainDrive Is (quick overview given on call)

  • MIT-licensed, modular alternative to ChatGPT that you own and control.
  • Frontend: React. Backend: FastAPI.
  • Default plugins: Chat interface, Ollama (local models), OpenRouter (API models).
  • Plugin Manager: 1-click install from GitHub, supports local zip install.
  • Docs at docs.brainedrive.ai; community at community.brainedrive.ai.
  • Roadmap phases: License → Foundation (ownership over interface/intelligence/memory/hosting/connections) → V1 polish (current) → Build → Monetize → Community-led innovation.

Dashboard & UX Improvements

  • Dashboard links added to key resources (docs, community, etc.). More contextual links planned project-wide.
  • Theme: default switched to Dark; removed “white flash” on auth/login.
  • Pages landing content updated; future: pin/favorite pages, folders, and “most used” tiles.

Quality & Fixes

  • Tasks timestamp fix: background task dates now reflect local timezone (not UTC).
  • System info export: Profile → Open System Info → downloadable JSON with non-sensitive environment details (OS, browser, commit, plugins & versions) to include in GitHub issues. Keys/chat content never included.

Models & Providers

  • Ollama models + background tasks: downloads now tracked in Tasks; progress also mirrored on the model page.
  • OpenRouter plugin:
    • Shows costs, token info, availability; quick model testing.
    • API key stored encrypted; masked in UI.
    • Optional plugin—skip if running fully local.

Personas

  • Personas = named system prompts + parameters for chats.
  • Quick edit: clicking a persona card opens editor.
  • Parameters framework expanded internally to enable future settings.

Plugin Install UX (big cleanup)

  • Old “long landing page” replaced with compact drop-link/drag-file UI and immediate feedback.
  • Supports:
    • GitHub URL install
    • Local .zip install (for private/custom plugins)
  • Security notice present (to be unified across flows).

Page Builder (recap)

  • Drag-and-drop pages from plugin modules; can mix modules from multiple plugins.
  • Publish to “Your Pages” with one click.
  • Demo showed non-chat experiences (e.g., small game) built via the same system.

Chat Interface Updates

  • Model picker includes OpenRouter models (filterable, e.g., “free”) and local Ollama models.
  • Persona selector integrated; persona adherence bugs from 2 weeks ago fixed.

“CAG” / Context Augmentation (First Step of “Chat with Docs”)

  • New document upload to chat context:
    • Accepts text/ASCII files (e.g., .md). (PDF support planned via a PDF-reader plugin; full-text docs offline reading planned.)
    • Two modes:
      • One-shot (no DB save; ephemeral)
      • Save to conversation (stored with chat; lives in DB)
    • Internals (MVP): document is segmented into window-fit segments; injected as context to the LLM (no vectors/metadata yet).
  • Demo validated: baseline “What is BrainDrive?” answer was wrong before; accurate after loading the whitepaper.
  • Note: temperature was high during some tests; hallucination caveat shown in UI.

DevRel, Docs & Community

  • Plugins now live in the Community (ad-hoc marketplace for now).
  • Intro course: “How to own your own AI system” — 9 lessons, text course done; videos planned. Designed for non-technical setup to fully working BrainDrive.
  • Navaneeth building Y-Finder: first community use-case plugin (helps users “find their why”); rock-paper-scissors was his first test plugin.

Avatar System (Novel Knowledge Packaging) — Concept & Early Demo

  • Problem with traditional RAG: setup complexity (DBs, embeddings, migrations), non-technical friction, varied local hardware.
  • Avatar idea: Modular, tradeable knowledge bases as PNG images containing embedded data (chunks + lightweight vector/graph structure). Think “trading cards for knowledge.”
  • Vision:
    • Create “Dave Jones — BrainDrive Dev” avatar; add more cards (e.g., D&D) and compose them at chat time.
    • Share/sell knowledge cards; build a decentralized knowledge economy where creators benefit.
    • Personas apply over avatars; supports multiple avatars combined (e.g., compare two sports teams’ stats).
    • Conversations/history could be stored inside the avatar; future editor to curate avatar contents (add/remove/fix).
  • Proof-of-concept:
    • Server side MCP source + plugin; image drag-drop → upload → use as context.
    • Worked in late-week demo; minor demo glitch live (still pre-pre-beta).
  • Next steps:
    • Build creator/editor UI for avatars.
    • Backend hooks to let plugins replace/extend pipeline stages (true modular backend).
    • Reconcile chat-doc upload + avatar creation/attachment flows (see “Memory UX” below).
42

Hi All,

Please find this week’s Dev Call Livestream recording followed by an AI powered summary of what was discussed below.

Questions, comments, ideas and concerns welcome as always.

Just hit the reply button.

Thanks,
Dave w.

Recording:

AI Powered Summary:

Quick context

  • Live weekly dev call; mission: build a superior user-owned alternative to big-tech AI.
  • Two roles: Dave Waring (operations) & David Jones (tech).

Last week recap & contest

  • Entered the 30-day r/localLLM contest; first broad public reveal.
  • Post metrics: 26 upvotes, 8 comments, ~13k views; GitHub stars roughly doubled (from ~12 to ~24).
  • Feedback “buzzwords” expected and confirmed: RAG and MCP.

Positioning & product foundation

  • BrainDrive = local + API models, runs offline for privacy.
  • MIT-licensed, modular, plugin-based, drag-and-drop page builder.
  • Designed to be built on vs locking users in.

Cloud strategy & portability (no lock-in)

  • Plan to support managed hosting for convenience-based monetization (not lock-in).
  • One-click import/export: move entire experience between cloud ↔ local via a compressed package.
  • Same open codebase for any host (GoDaddy/your own cloud/etc.). No separate enterprise fork; enterprise features could be plugins.

Multi-device experience

  • Targeting phone/tablet/desktop parity for end-user UX; page-builder on mobile is TBD/nice-to-have.

Immediate weaknesses to address

  • RAG & MCP demand from builders.
  • Mac installer still needs finishing/polish.

Security & multi-tenant readiness

  • Move from local-only assumptions to internet-exposed hardening.
  • Build out multi-user/tenant/roles/permissions (framework exists, needs full integration).
  • Secure endpoints; guard against prompt/SQL/data injection; JWT/refresh token practices reviewed and verified.

Logging/observability

  • Add system-wide logging for plugins and core; proactive alerts (especially critical for managed hosting).
  • Make it easy for non-technical users to submit actionable bug info; enable centralized fixes/rollouts.

Plugin system modernization (highlights)

  • Expand to backend adapters (e.g., swappable chunkers/pipelines).
  • Clear data-flow docs; fix caching; live module reload for devs.
  • Preload/prefetch key plugins for faster perceived load.
  • Inter-plugin composition and dependencies (use functionality from other plugins without code copying).
  • Integrate with builder configs; enforce security/permissions awareness.

Avatar (BrainDrive’s take on RAG)

  • “Avatar” = portable image artifact encapsulating vectors + files (hide DB complexity).
  • Load avatars per slot to constrain context (e.g., Yankees stats, persona chats).
  • Will become an MCP server so other plugins can call it.
  • Current goal: improve chunking/search; compare performance vs classic RAG.

Original timeline (then revised later)

  • Start: Jan 2.
  • Best-case: Mar 2; realistic: May 4 (Mondays used as milestone anchors).
  • Large scope included: plugin modernization, user management, security, logging, responsive UX.

Personas & go-to-market focus

  • Adam Carter (builder/dev): wants MCP, deep plugin graphs, sophisticated RAG.
  • Katie Carter (everyday user): wants guided, tailored chat use-cases that feel like talking to a person; privacy & control.
  • Agreement: focus first on Katie (monetizable guided chat use-cases), while keeping builders in mind.

Managed hosting: why sooner

  • Many users want “easy button” cloud without running local.
  • Early hosting (even minimal) opens revenue + feedback loops; no downside—refund/waitlist if features aren’t ready.

RAG plan — staged

  1. CAG first (“Chat-Augmented Generation”):
  • Chat with 1+ documents without embeddings; respect context window.
  • Support text/ASCII types + PDF (tables handled via robust parsing), Word via simple copy-paste initially (native support later).
  1. Full RAG (embeddings + vector DB):
  • Document manager, embeddings store, retrieval, chunking.
  1. Avatar: portable encapsulation of vectorized knowledge; later MCP-enabled.
  • Parallel option: MCP orchestration to an existing open-source RAG (e.g., Bex) for speed, without building full MCP substrate yet.

MCP approach

  • Two tiers:
    • Targeted orchestration: hard-wire calls to a specific MCP server to ship faster.
    • Full MCP substrate later for discovery/generalization & plugin access.

Marketing updates

  • Dave W built a Gemini-driven image pipeline (brand-guided prompts, logo/mascot optional). Useful for scaling visuals across web/video.

Navaneeth’s guided chat engine (Why Finder)

  • Implemented a phase-based guided prompt system (counter-gated stages with prompt folders).
  • Reusable engine pattern for many guided use-cases; beyond current market norm.

Decisions Made (Concrete)

  • Primary near-term focus = Katie Carter (guided chat use-cases + hosted option).
  • New immediate sequence (pivot):
    1. Mac installer (finish & ship).
    2. CAG = Chat with document(s) without embeddings (text/PDF first).
    3. RAG = embeddings/vector DB (either integrate Bex or similar via targeted MCP; or build native if faster/cleaner).
    4. Security & logging to enable managed hosting at scale.
    5. Avatar after CAG/RAG; or sooner only if it becomes trivially fast.
  • MCP (full) deprioritized; do targeted MCP if leveraging an external RAG speeds delivery.
  • Begin building a waitlist + possibly an in-product polling plugin for feature prioritization.
  • Keep no lock-in portability (import/export) as a core promise.
43

Hi All,

Please find this week’s dev call livestream recording, followed by an AI powered summary below.

We livestream these calls every Monday at 10am EST on the BrainDrive Youtube Channel and the call is open to anyone who would like to participate.

Questions, comments, concerns, and ideas are also welcome here, just hit the reply button.

Thanks,
Dave

Recording:

AI Powered Summary:

Livestream Intro (Mission & Framing)

  • Weekly Brain Drive dev call, Mondays 10 a.m. ET.
  • Mission: build a superior, user-owned alternative to big-tech AI.
  • Modular, MIT-licensed, plugin-based architecture; default chat UI is fully modifiable/forkable.
  • Infinite Craft shown as an example of extensibility.

Mac Installer (Apple Notarization)

  • Mac installer went through Apple’s notarization/stapling.
  • First run was rough (new to Mac dev), but approved now and available for people to “bang on.”
  • Process improvement: subsequent notarization dropped from ~2.5 days to ~5 minutes after guidance.
  • Expect faster future iterations.

CAG (Context-Augmented Generation) Upgrade

  • New document ingestion in chat: PDF, DOCX, PPTX, HTML, Markdown, EPUB, ODT, RTF.

  • Minimal preprocessing; in-memory (no DB); fully local—no internet required.

  • “One-shot” vs “Save to conversation”:

    • One-shot: load, ask, then drop to preserve context window; enables hopping across docs.
    • Save: persists relevant excerpts in chat history for ongoing use.

  • Upcoming: quick “drop from context” control.

  • Use case: cherry-pick relevant sections (e.g., 2 pages out of 100) to keep context lean.

Privacy & Ownership Emphasis

  • Everything runs locally on your machine (“your backend”); no data leaves the device.

Plugin Installer Improvements

  • UI/UX polish; added security notice to panel.
  • Side menu now auto-updates after install/uninstall; no manual refresh.
  • Fixed navigation error on first load.
  • Default install timeout increased to 120s.
  • Overall better “one-click” lifecycle (install/update/remove).

White-Labeling & Helpful Links

  • Updated default welcome message with quick links (Docs, Community, BrainDrive) in header/footer across the app.
  • White-label work took longer due to bug found/fixed.

YFinder & Ikigai Use Case

  • YFinder plugin: guided chat to derive a personal “Why” (based on Simon Sinek).
  • Next: add Ikigai (what you love/are good at/the world needs/can be paid for).
  • Persona system: store Why/Ikigai into a persona for contextual advice (career moves, goals, etc.).
  • Idea: daily “personal dashboard” powered by Avatar system—reminders, journaling, wins/losses, motivational nudges; no extra DB tables needed if backed by personas/avatars.

Training & Course Content

  • “How to Own Your AI System” course on the forum (10 lessons; currently text + new videos).
  • 5 of 9 videos produced using Descript; editing agents/automation highlighted.
  • Broader note: rapid improvements in image/audio tooling.

Roadmap & Foundation Status

  • Five-phase roadmap on docs; “foundation + polish” underway.

  • Current foundation pieces:

    • Installer v1 (done), Chat UI
    • Local models (Ollama) & API models (OpenRouter)
    • Personas
    • CAG (demoed), RAG in progress next
    • Page Builder (drag-and-drop)
    • Plugin system (1-click install/update/delete from any GitHub)
    • Docs site & training materials
    • Planned: Brain Drive Concierge (AI support)

RAG (Retrieval-Augmented Generation) Plan

  • Architecture:

    • Separate background processes (likely FastAPI); move beyond Docker-only; clean port mgmt.
    • RAG will be a non-default plugin (to keep first-run simple/light).

  • UX goals:

    • Single chat page; when RAG is installed, new controls appear (no extra page).
    • Adopt “+” menu near input (like OpenAI/Claude) for uploads/knowledge connections and mobile friendliness.
    • Build “Projects/Knowledge Bases” (collections of docs) via a RAG button/flow.
    • Background processing: chunking (target ~2k tokens), embeddings, and auto Q&A generation at ingest for faster, validated retrieval.
    • “Connect to” selector at input to ground chats in one or multiple projects.
    • Page Builder config: set a default project so a page auto-loads its knowledge base.

  • CAG vs RAG:

    • CAG: minimal processing; drops chunks into context; no LLM at ingest.
    • RAG: full indexing pipeline (embeddings, chunks, Q&A) with persistent vector DB for any future chats.

UI Considerations

  • Follow established patterns (Claude/OpenAI): keep RAG/CAG actions in the input area’s “+” menu.
  • Helps avoid clutter and works well on mobile.

Community & Outreach

  • Clip CAG demo and post to community forum; solicit format requests/bug reports.
  • Share progress update on r/localLLaMA (follow-up to contest entry).
  • GitHub Project board shows to-do’s; invites community contributions.

Near-Term Focus (as discussed)

  • Dave J: Implement/install RAG backend processes; then wire up UI controls on the main chat page.
  • Dave W: Finish training videos; coordinate outreach; plan Concierge spec; show YFinder soon.
  • Navineeth: Wrap Ikigai; then start on Concierge (ML/fine-tuning background suits it).