OpenStudy: The Self-Hosted AI Study Stack That Teaches

Let’s be honest: most “study dashboards” are glorified to-do lists with a coat of academic paint. You get Notion templates, Obsidian plugins, or Trello boards tagged “Finals Week — DO NOT OPEN”. But what if your dashboard could actually teach? Not just track deadlines — but read your lecture PDFs, summarize your notes, generate practice questions, and even simulate office hours with your actual course materials? That’s what OpenStudy does — and it runs on your own server, with Claude whispering into your terminal via an embedded MCP (Model Context Protocol) server. At 44 stars on GitHub (as of May 2024), it’s tiny — but *it’s the first self-hosted study stack I’ve seen that treats AI not as a chatbot, but as a co-instructor. I’ve run it for 11 days across two courses (a grad-level NLP seminar and a systems programming lab), and — spoiler — it caught a typo in my own lecture notes before I did.

What Is OpenStudy? A Self-Hosted Study Dashboard with Real AI Integration

OpenStudy is a TypeScript-based desktop-grade web app (Electron-style UI, but served via Express + React) that stitches together three tightly coupled layers:

• A local course/content manager (supports PDFs, Markdown, MP4s, and even .ipynb notebooks)
• A persistent, encrypted local knowledge graph (built on SQLite + custom vector embeddings)
• An embedded MCP server — not a proxy, not a wrapper — a fully compliant, spec-compliant MCP server (v0.2.1) that exposes your entire course context to LLMs with zero internet callouts when running offline

Crucially: it doesn’t require Claude — but it’s designed for it. The MCP server is pre-configured to serve claude-3-haiku-20240307 (via Anthropic’s official API) or any local LLM via llama.cpp/Ollama (tested with phi-3:mini and gemma:2b). The magic is in the context binding: OpenStudy doesn’t just send a prompt. It injects course syllabi, annotated PDFs, your handwritten notes, past quiz answers, and deadline metadata directly into the MCP tools and context slots. That means when you ask “Explain the CAP theorem using examples from Lecture 7”, Claude isn’t hallucinating — it’s pulling from your actual Lecture_7_Consistency_Models.pdf with your own margin annotations embedded.

Unlike Obsidian + Copilot plugins (which are API-bound and opaque), or Notion AI (which can’t read local files without messy sync), OpenStudy owns the full stack — and it’s MIT-licensed.

How to Install and Run OpenStudy (Docker-First, But Also Bare Metal)

The fastest path is Docker. The repo includes a docker-compose.yml, but it’s minimal — I’ve extended it for production-like reliability (persistent volumes, healthcheck, non-root user). Here’s what I actually use:

# docker-compose.yml
version: '3.8'
services:
  openstudy:
    image: ghcr.io/openstudy-dev/openstudy:0.4.2
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      - NODE_ENV=production
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY:-}
      - OPENSTUDY_DATA_DIR=/data
      - MCP_PORT=8081
    volumes:
      - ./openstudy-data:/data
      - ./openstudy-config:/app/config
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3000/health"]
      interval: 30s
      timeout: 5s
      retries: 3
    user: "1001:1001"

Then run:

export ANTHROPIC_API_KEY="sk-ant-api03-..."
docker compose up -d

You’ll need a .env file (not committed!) containing your key — never hardcode it. The app will auto-detect if ANTHROPIC_API_KEY is missing and fall back to local LLM mode.

For bare-metal installs (I run this on an old Mac Mini M1, 16GB RAM), clone and build:

git clone https://github.com/OpenStudy-dev/OpenStudy.git
cd OpenStudy
git checkout v0.4.2  # latest stable as of May 2024
npm ci
npm run build
npm start

It’ll launch http://localhost:3000. First-run setup asks for your course root directory — point it to ~/courses/ or wherever your syllabi live.

OpenStudy vs. Obsidian + AI Plugins vs. Notion AI: Why Context Ownership Matters

Let’s cut the fluff. If you’ve tried Obsidian with the Smart Connections plugin or AI Assistant, you know the pain: prompts time out, PDFs get truncated, and vector indexes rebuild every time you restart. Notion AI? It cannot read local files — only what you manually paste or upload to Notion’s servers (and yes, that is processed on their infrastructure, per their Privacy Policy). OpenStudy does none of that.

Here’s the real differentiator: context fidelity.

I tested all three on the same 32-page PDF lecture (Distributed_Consensus.pdf). OpenStudy returned 5 precise, citation-backed answers in <8s (with claude-3-haiku). Obsidian’s plugin returned 2 answers — one hallucinated a theorem name that didn’t exist. Notion required me to re-upload the PDF every time, and refused to answer anything referencing “page 17” unless I manually scrolled there.

That said: OpenStudy isn’t a replacement for Obsidian’s daily notes. It’s a course operations system. Think of it as Airtable + Anki + Claude, but for structured academic workflows.

Configuration Deep Dive: Customizing Your MCP Server and Embedding Models

OpenStudy ships with sane defaults, but the real power is in config/mcp.json. Here’s my tweaked version for low-resource use (running on a Raspberry Pi 5 with 8GB RAM):

{
  "mcp": {
    "port": 8081,
    "host": "0.0.0.0",
    "max_context_length": 16384,
    "timeout_ms": 120000
  },
  "embedding": {
    "model": "intfloat/multilingual-e5-small",
    "batch_size": 16,
    "normalize": true
  },
  "llm": {
    "provider": "ollama",
    "model": "phi-3:mini",
    "base_url": "http://host.docker.internal:11434",
    "temperature": 0.3,
    "max_tokens": 1024
  }
}

Key notes:

• multilingual-e5-small is tiny (37MB) and blazing on CPU — I get ~120ms embedding latency vs. 1.4s for all-MiniLM-L6-v2 on the same hardware.
• phi-3:mini runs at ~8 tokens/sec on the Pi 5 — enough for draft explanations, but not for long-form synthesis. For that, I switch to claude-3-haiku over the API.
• host.docker.internal is critical for Docker-in-Docker LLM routing — localhost won’t work from inside the container.

You must restart the service after editing mcp.json. There’s no hot-reload.

Why Self-Host This? Who Is OpenStudy Actually For?

Let’s be blunt: OpenStudy isn’t for casual students cramming for midterms. It’s for:

• Grad students & researchers managing 3–5 concurrent courses with original research components (e.g., reading 50+ papers, building custom datasets, writing annotated code)
• Professors building course materials who want AI-assisted grading scaffolds, auto-generated rubrics, or student Q&A bots trained only on their lecture notes — not Stack Overflow
• Self-directed learners studying niche domains (e.g., I’m using it for embedded Rust + RISC-V toolchain docs) where public LLMs have zero training data
• Privacy-obsessed academics who’ve read Anthropic’s data policy and still don’t want lecture notes flowing through their API — even with --no-data-collection flags

Hardware-wise:

• Minimum: 4GB RAM, 2 vCPUs, 10GB disk (for <5 courses, mostly PDFs)
• Recommended: 8GB+ RAM, SSD, 4 vCPUs (for >10 courses + video lecture transcripts)
• Storage: My 12-course setup (PDFs, notes, 3x 45-min lecture MP4s with Whisper transcriptions) uses 4.2GB — mostly SQLite bloat from embeddings; vacuuming shaves off ~30%.

It’s not for high-school students or undergrads who just need a calendar. It’s overkill — and that’s the point.

The Verdict: Is OpenStudy Worth Deploying Right Now?

Yes — if you’re willing to tinker and value context sovereignty over polish.

I’ve run v0.4.2 for 11 days. The good:

• Deadlines sync reliably with iCal feeds (I pull from my department’s Google Calendar via ics import)
• PDF annotation sync works — highlight text in OpenStudy, and it shows up in the sidebar and gets injected into MCP context
• MCP server is rock solid — I’ve had zero crashes, and Claude responses are consistently grounded
• Search is fast — Ctrl+K finds “Raft consensus” in 82ms across 14 courses

The rough edges (and there are a few):

• No mobile app — and the PWA is half-baked. Don’t expect to use this on your phone.
• Video support is “experimental” — Whisper transcriptions work, but syncing timestamps to slide PDFs? Not yet. I manually split MP4s and upload transcripts as .txt.
• No user accounts — it’s single-user only. No sharing courses or collaborative annotations.
• Importing from Notion/Obsidian is CLI-only — npx openstudy-import --notion-token ... works, but the docs assume you know Node’s npx flow.

Also: the GitHub star count (44) reflects its niche appeal — not instability. This is a very early project (first commit: Jan 2024), but the architecture is sound. The maintainer (a PhD candidate in EdTech at TU Delft) ships weekly — I’ve already had two PRs merged for config tweaks I requested.

So — is it production-ready? Not for your department’s 300-student course. But for your personal academic stack? Absolutely. I’ve replaced my Notion course DB, my Obsidian flashcards, and my Google Keep deadline tracker — all with one self-hosted tab. And when Claude corrected my typo in Consistancy_Models.pdf (I’d written “Consistancy” — twice — and it caught it in context), I knew: this isn’t just another dashboard. It’s the first real step toward AI as a pedagogical co-pilot — not a chatbot. I’m keeping it running. And I’m watching those GitHub stars closely.

One last tip: run docker exec -it openstudy npx prisma migrate dev --name init once after first launch — the embedded SQLite sometimes needs a manual schema bump. It’s not in the docs. I found it in the GitHub issues. That’s the self-hosting life.