Bill Grant

Presales Engineer learning and sharing knowledge about infrastructure, development, and AI.

Music Graph Project: Upgrading My AI Workflow with MCP

6 minute read

This is somewhat of a one off post for the project. I was feeling the pain of all the cutting and pasting I was doing. This is caused a problem for me because I didn’t want to relinqish full control to AI with something like claude code. I also didn’t want to pay per api call/token. I came up with the idea of using MCP servers as a bridge. This way I could still control the code, but offload boring tasks to Claude like writing these blog posts. Below is the unedited post describing our MCP setup written by Claudecd

Before diving into Phase 6 (CI/CD), I needed to solve a growing pain point in my development workflow. The copy/paste approach that worked fine in Phase 1 was becoming a significant friction point as the project grew.

The Problem

My workflow through Phase 5 looked like this:

  1. Have a conversation with Claude about what to build
  2. Copy code from my editor into Claude
  3. Get suggestions/fixes from Claude
  4. Copy code back to my editor
  5. Repeat for every file that needed changes

For small tasks: Annoying but manageable.

For Phase 5 deployment: Painful. I was juggling terraform files, Docker configs, Nginx configuration, Python code, and environment variables across multiple sessions. The context window limits meant I couldn’t show Claude everything at once.

For Phase 6 and beyond: Unsustainable. CI/CD will touch even more files across multiple repositories.

The Options I Considered

Option 1: Keep the current workflow

  • Pros: Free (included in $20/month Claude Pro), familiar
  • Cons: Doesn’t scale, wastes time, limits what’s possible

Option 2: Switch to Cline (VS Code extension with API)

  • Pros: Direct file access, works in my editor
  • Cons: API costs (variable, potentially expensive), changes my interface

Option 3: Use Model Context Protocol (MCP)

  • Pros: Direct file access, uses existing Claude Pro subscription, same interface
  • Cons: Newer technology, requires setup

I went with MCP. Here’s why and how.

What is MCP?

Model Context Protocol is a standard way to give AI assistants access to external data sources and tools. In my case, MCP servers give Claude Desktop direct read/write access to:

  • My local file system
  • GitHub repositories
  • Potentially databases, APIs, or other services (future use)

The key insight: This isn’t about replacing Claude - it’s about giving the same Claude I’ve been working with better access to the project files.

Why MCP Over API-Based Tools

Cost: MCP uses my existing Claude Pro subscription ($20/month). API access with Cline would add variable costs that could get expensive during deep coding sessions.

Continuity: The entire Music Graph project has been a “journey with Claude.” Switching to a different AI model or interface would break that narrative, especially since I’m documenting the process on my blog.

Familiarity: I’m already comfortable with Claude Desktop’s interface. MCP just enhances it rather than requiring me to learn a new tool.

Control: I still review and approve every change. MCP gives Claude file access, not autonomous execution.

What I Set Up

I configured three MCP servers:

1. GitHub MCP Server

  • Access to music-graph repository
  • Access to blog repository (billgrant.github.io)
  • Can read code, create branches, view issues

Why: Some code changes happen on the GCP VM and are only visible in the GitHub repo. This solves the “code exists but I can’t easily show it to Claude” problem.

2. Local Music-Graph Filesystem

  • Direct access to /home/billgrant/code/music-graph
  • Read/write terraform files, Docker configs, Python code
  • Test changes before committing

Why: For local development and changes I want to test before pushing to GitHub.

3. Local Blog Filesystem

  • Direct access to /home/billgrant/code/billgrant.github.io
  • Create/edit blog posts, update project documentation

Why: Creating blog posts involves updating multiple files (new post, intro post, README). MCP lets this happen in one conversation instead of multiple copy/paste cycles.

The Setup Process

Prerequisites:

  • Claude Desktop installed
  • Node.js/npx available (for running MCP servers)
  • GitHub personal access token

Configuration file location:

  • Windows: %APPDATA%\Claude\claude_desktop_config.json
  • Mac: ~/Library/Application Support/Claude/claude_desktop_config.json

My configuration:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
      }
    },
    "filesystem-music-graph": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "\\\\wsl$\\Ubuntu\\home\\billgrant\\code\\music-graph"
      ]
    },
    "filesystem-blog": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "\\\\wsl$\\Ubuntu\\home\\billgrant\\code\\billgrant.github.io"
      ]
    }
  }
}

Note the WSL path format: \\\\wsl$\\Ubuntu\\... allows Windows applications to access WSL2 file systems.

After editing the config:

  1. Save the file
  2. Completely quit Claude Desktop (not just close - quit from system tray)
  3. Restart Claude Desktop
  4. MCP tools appear automatically in conversations

Testing the Setup

To verify everything worked, I had Claude:

  1. Read the music-graph README from GitHub
  2. List files in the local music-graph directory
  3. List files in the blog directory

All three operations succeeded without any copy/pasting on my part.

What This Changes

Old workflow (writing a blog post):

  1. Draft post with Claude in chat
  2. Copy post content to new file
  3. Open intro post and copy to Claude
  4. Get updated intro post
  5. Copy back to file
  6. Open README and copy to Claude
  7. Get updated README
  8. Copy back to file

New workflow: “Create Phase X blog post, update intro post to link to it, and update README progress”

Claude does all of it in one conversation. I review the changes and commit.

For Phase 6 work:

  • Claude can read terraform configurations directly
  • Can update multiple docker-compose files in one go
  • Can reference GitHub issues and pull requests
  • Can create documentation alongside code changes

Cost Comparison

Current setup (MCP with Claude Pro): $20/month (what I was already paying)

If I had gone with Cline/API: $20/month (Pro) + variable API costs

  • Light usage: maybe $10-15/month additional
  • Heavy coding sessions: could be $30-50/month or more
  • No built-in spending limits (risk of surprise bills)

For a personal project where I’m already taking breaks when I hit message limits, the fixed cost model works better.

What I’m NOT Changing

I’m still doing the coding. MCP gives Claude better context and eliminates copy/paste friction, but I’m still:

  • Making architectural decisions
  • Writing the code (with assistance)
  • Understanding what I’m building
  • Learning the technologies

This isn’t about letting AI write my project - it’s about removing workflow friction so I can focus on learning and building.

Future MCP Plans

Once I have the Music Graph API built (future phase), I’m planning to:

  • Build a custom MCP server that wraps the API
  • Explore what it means to query my own application through Claude
  • Learn MCP server development as a skill

This is partly learning (“how do you build an MCP server?”) and partly exploration (“what would conversational access to my music graph look like?”).

Lessons Learned

MCP is new but stable enough: I was concerned about using newer technology, but the filesystem and GitHub servers worked immediately without issues.

WSL path quirks: The \\wsl$\Ubuntu\... path format was the only real gotcha. Standard WSL paths didn’t work from Windows applications.

Three servers is the right balance: GitHub for reference, local filesystems for active work. More than that might be overkill for this project.

Setup time investment: Took about 30 minutes total, including generating the GitHub token and figuring out the WSL path format. Well worth it.

What’s Next

With MCP in place, I’m ready to tackle Phase 6: CI/CD and DevOps. The workflow improvements will be especially valuable for:

  • GitHub Actions configuration (YAML files)
  • Terraform updates (infrastructure changes)
  • Documentation updates (README, blog posts)
  • Managing multiple environments (dev/prod)

The goal for Phase 6 is to enable continuous development without disrupting Aidan’s use of the production application. MCP makes the multi-file, multi-repo coordination much more manageable.

Alternative: Try Cline Later

I’m not ruling out Cline entirely. Once I have experience with MCP, I plan to:

  • Try Cline for one complete phase (maybe Phase 7)
  • Compare the experience and costs
  • Write a blog post comparing the two approaches

This gives me data to make an informed decision rather than just picking one tool blindly.

Resources

MCP Documentation:

MCP Servers I’m Using:

Claude Desktop:

This post documents a workflow improvement that makes the rest of the Music Graph project more sustainable. Sometimes the best development work is improving your development process itself.

This is part of the Music Genre Graph project series. See the project introduction for the full roadmap.

You May Also Enjoy

Music Graph Project: Database Integration

3 minute read

Claude and I were able to sucessfully move to sqlite from a file with a dict in it. I hit my session limit with Claude ($20 plan) tonight. Mostly because I w...