Cursor and Claude Code connecting to CodeGraph over MCP to map Vue and Spring Boot call chains

If you ship API changes with Cursor or Claude Code and the backend merges while the frontend stays stale—you are not alone. This post answers three things only: why edits get missed, a real OrderDTO case, and how CodeGraph fixes it on Vue 3 + Spring Boot via CodeGraph and MCP.

Bottom line: before changing OrderDTO.amount, run codegraph_impact—it lists Java services and Vue createOrder plus the Pinia store in one pass, the ring agents skip most often.

Why Cursor keeps missing the frontend

Missed files are rarely “the model can’t code.” AI Coding tools fail on cross-directory, cross-language references. On Vue + Spring Boot splits, three causes cover most incidents:

1. Context window: only the open file fits

Cursor @-mentions and Claude Code Read calls are bounded. The agent stares at OrderController.java and never learns frontend/src/api/order.ts shares the same DTO field. New chats and branch switches make “what we already changed” harder to track—worse stacked with Cursor forgetting across weeks.

2. Grep: finds text, not call graphs

Default exploration uses grep. Searching amount pulls logs, tests, and dead constants—not who calls OrderService.createOrder or which @PostMapping backs the route. Tokens go to finding entry points, not fixing full blast radius.

3. No impact analysis: one file fixed, ten orphaned

Humans ask: if I change this field, what else breaks? Without structured impact, agents “finish Java” and leave TypeScript, Pinia, and tests for a follow-up you never scheduled.

The fix is not always a bigger model—it is queryable call graphs, edges, and route entry points for the agent. The order API below shows how.

Real case: OrderDTO.amount

Task: on POST /api/orders, change amount from number to string (e.g. large values or formatted strings). Repo layout: backend/ (Controller → Service → OrderDTO), frontend/ (api/order.ts → Pinia → checkout view).

Without CodeGraph: what Cursor / Claude Code often skip

I gave only the business description—no @ files. Typical outcome:

  • ✅ OrderDTO.java, OrderService updated
  • ❌ frontend/src/api/order.ts createOrder payload types
  • ❌ useOrderStore field mapping for amount
  • ❌ checkout v-model still validated as numeric

mvn compile may pass; pnpm build sometimes does too—then integration or production breaks. That is “API changed, frontend forgotten.”

With impact: blast radius (excerpt)

codegraph_impact
  symbol: "OrderDTO.amount"

→ OrderService.createOrder
→ OrderController.create
→ frontend/src/api/order.ts :: createOrder
→ stores/order.ts :: useOrderStore

The last line is what grep used to miss. Edit against the list in Cursor or Claude Code and miss rates drop.

How CodeGraph surfaces the blast radius

CodeGraph Tree-sitter-indexes Java / TS / Vue scripts locally, stores call edges in .codegraph/, and exposes codegraph_* tools over MCP. Data stays on the machine by default.

For this order change I always run:

  1. codegraph_context — task-sized pack of Controller, DTO, frontend API entry
  2. codegraph_trace — Spring: OrderController.create → OrderMapper.insert
  3. codegraph_impact — expand from OrderDTO.amount across Java + Vue + store
  4. codegraph_explore — related methods only, not an 800-line service dump

When HTTP paths and axios strings lack symbol edges, impact from the DTO still finds the frontend—that is the “better than expected” step here. Tooling deep dives and RAG comparisons: code knowledge graph roundup.

In AGENTS.md, require codegraph_impact before DTO edits and list frontend/src/api plus Pinia—more reliable than “don’t forget the frontend.”

Install (about 5 minutes)

At the repo root with frontend/ + backend/ (macOS):

curl -fsSL https://raw.githubusercontent.com/colbymchenry/codegraph/main/install.sh | sh
# or: npx @colbymchenry/codegraph

codegraph install --target=cursor --yes
cd /path/to/your-repo
codegraph init -i
codegraph status

First full index: roughly 10–20 minutes depending on size; exclude node_modules, target, dist. Saves debounce ~2s incremental sync; on ⚠️ Pending sync, have the agent Read source.

Results compared

ApproachTool calls (same task, informal)Frontend on the checklist?
Grep + Read only~15+Often misses Pinia / API layer
CodeGraph MCP first~5–6impact lists front and back together

Official Java benchmark (OkHttp ~645 files): median 10 → 3 tool calls (2026-05-29). Vue + Spring splits felt similar. Graphs do not replace tests—run mvn test and pnpm test:unit before merge.

Where to run indexing on large repos

First codegraph index spikes CPU, SQLite writes, and fan noise—if IDEA builds Spring and pnpm builds Vue at the same time, even Cursor MCP queries stutter.

Teams often put clone + full index + scheduled rebuilds on a Mac mini, CI node, or Cloud Mac; laptops stay for editing and MCP queries. I run indexing on a rented Macstripe M4, staggered from local builds; see enterprise Mac CI FAQ for worktree patterns.

A dedicated “CodeGraph on Cloud Mac” post is worth its own article—here we only note: separate indexing from interactive work.

Summary

Cursor missing the frontend on API changes usually means limited context + grep without calls + no impact. On Vue + Spring Boot, CodeGraph MCP with context → trace → impact aligns DTO blast radius in one list and cuts exploration from dozens of greps to a few structured queries.

Default workflow: init index → impact before DTO edits → edit the list → test. Concept posts, Claude Code on huge repos, and Cloud Mac deployment can be a series—links below.

Related reading