Skip to main content
Glama
Onboarding MCP Server
by fabimelo

Onboarding MCP Server 🚀

A local-first Model Context Protocol (MCP) server that empowers AI coding assistants (e.g., Cursor, Claude Code, Antigravity IDE) to autonomously map codebases, transcribe onboarding videos with keyframe screenshots, and maintain structured knowledge vaults in Obsidian directly from IDE chat interactions.


🌟 Key Capabilities

  1. set_vault_path: Dynamically configure the active Obsidian vault directory for session state from IDE chat.

  2. set_workspace_path: Dynamically configure the target codebase workspace directory for session state from IDE chat.

  3. get_codebase_structure: Recursively map code directory structures and detect dependency manifests, respecting .gitignore (uses configured session workspace path or optional workspace_path parameter).

  4. process_video: Transcribe onboarding videos using faster-whisper (CPU int8), extract scene keyframes via OpenCV, and output timestamp-aligned transcript data.

  5. write_obsidian_note: Write structured Markdown notes and MOCs (Maps of Concepts) directly into the user's local Obsidian vault (uses configured session vault path or optional vault_path parameter).


Related MCP server: knitbrain

🚀 Quickstart

Build and run the containerized server with pre-packaged ffmpeg and dependencies. Note: because Docker containers run in an isolated environment, volume mounts (-v) are required to grant the container access to host directories specified in chat:

# Build the Docker image
make build-docker

# Run container (mount host directories so chat can access them)
docker run -i --rm -v $HOME:$HOME onboarding-mcp-server

Option 2: Local Python Environment (No Volume Mounts Needed)

Runs directly on your host OS. Any absolute path passed from IDE chat works natively without volume mounts.

Requires Python 3.11+ and ffmpeg installed on host (brew install ffmpeg on macOS).

# Install dependencies into virtualenv
make setup

# Run the tests
make test

# Run the MCP server over stdio
.venv/bin/python -m onboarder.server

⚙️ IDE Chat Integration & Setup

The IDE chat assistant can configure workspace and vault paths dynamically at any point during a chat session:

  • set_workspace_path(path="/path/to/repo")

  • set_vault_path(path="/path/to/ObsidianVault")

Alternatively, individual tools (get_codebase_structure, write_obsidian_note, process_video) accept optional workspace_path and vault_path arguments directly.

Docker Configuration Example (claude_desktop_config.json / Cursor / Antigravity)

Mount your user home directory (or relevant code/vault folders) so paths passed in chat are accessible:

{
  "mcpServers": {
    "onboarding-mcp": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-v",
        "/Users/yourname:/Users/yourname",
        "onboarding-mcp-server"
      ]
    }
  }
}

Local Python Configuration Example

{
  "mcpServers": {
    "onboarding-mcp": {
      "command": "/absolute/path/to/onboarding-mcp/.venv/bin/python",
      "args": ["-m", "onboarder.server"]
    }
  }
}

🛠 Developer Workflow

make setup    # Set up venv and install dev dependencies
make test     # Run pytest suite
make lint     # Run ruff check and mypy type checking
make format   # Run ruff formatter

📄 License

MIT

Available Tools

5 tools
get_codebase_structureA

Recursively scan workspace directory and return file tree and dependencies, respecting .gitignore.

Inputs: workspace_path. Returns: result

process_videoA

Process onboarding video: extract audio, transcribe with Whisper, extract scene keyframes, and return timestamp-aligned JSON payload.

Inputs: video_path (required), output_dir, vault_path, extract_frames. Returns: result

set_vault_pathB

Set the active Obsidian vault directory path for the session state.

Inputs: path (required). Returns: result

set_workspace_pathA

Set the active workspace directory path for the session state.

Inputs: path (required). Returns: result

write_obsidian_noteC

Write a markdown note into the active Obsidian vault directory.

Inputs: content (required), note_path (required), vault_path. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.5/5.0

    Scored across 5 tools

    Disambiguation4/5

    Tools are mostly distinct, but set_vault_path and set_workspace_path have near-identical names and purposes, differing only by target directory. The other three tools (get_codebase_structure, process_video, write_obsidian_note) are clearly distinct actions.

    Naming Consistency5/5

    All tool names follow a consistent verb_noun pattern: set, set, get, process, write. The nouns are descriptive and uniform in style, making the API predictable.

    Tool Count5/5

    Five tools are well-scoped for an onboarding workflow, covering path setup, codebase analysis, video processing, and note writing without unnecessary bloat.

    Completeness4/5

    The toolset covers the core onboarding steps, but there are minor gaps such as no tool to list or manage existing notes, and no way to inspect the video metadata before processing. These are workable but not exhaustive.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      A local-first MCP server that gives AI coding agents persistent memory and controlled commands. Features a git-backed markdown knowledge vault with FTS5 search, surgical section edits, token-aware context budgeting, and a sandboxed command engine with human approval gates. Works with Claude Code, Cursor, Copilot, Gemini, and more.
      62
      1
      Apache 2.0
    • A
      license
      A
      quality
      C
      maintenance
      Local-first MCP server that gives any AI coding agent per-project memory, workflow intelligence, and always-on, lossless token & context optimization.
      37
      31 npm
      6
      MIT
    • F
      license
      Not graded
      quality
      D
      maintenance
      A local MCP server that gives AI agents structured access to a personal Obsidian knowledge vault, with semantic search, organization through Maps of Content, and git-backed history.
      -