VerveContext

Ground Cursor with live sources

Cursor knows your codebase. VerveContext gives it the outside world. Add one entry to .cursor/mcp.json and 300+ live sources become MCP tools inside the editor — so your agent codes against real prices, rates, geo and web data while you build.

  • .cursor/mcp.json
  • In-editor tools
  • Live values
Get grounded→All frameworks
Why ground Cursor

Real data, without leaving the editor

For the developer building agentic and data-touching features against facts instead of placeholders.

Real data in the editor

Cursor's agent can already read your codebase; VerveContext gives it the outside world too. Ask it to wire up a currency conversion or a weather widget and it works against the actual live value, not a placeholder it made up.

  • In-editor
  • Live values

Sources as tools while you code

Each enabled source shows up as an MCP tool the Cursor agent can call mid-task — inside an agentic edit, a chat, or a composer flow — so a build step can verify a real fact before it writes the code that depends on it.

  • Agentic edits
  • Composer

Per-project scope

Drop the config in a project's .cursor folder and the grounding travels with that repo. Scope the key to just the sources that project needs — a fintech repo gets markets, a maps repo gets geo.

  • Per-repo config
  • Scoped keys
Setup

Add VerveContext to .cursor/mcp.json

Cursor reads MCP servers from a project .cursor/mcp.json or your global settings — add the endpoint and your scoped key, enable it, and the sources appear as tools.

  1. 01

    Create .cursor/mcp.json in your project

    Cursor reads MCP servers from a .cursor/mcp.json file (project-level) or your global Cursor settings. Create the file at your repo root if it doesn't exist yet — it holds an mcpServers object.

  2. 02

    Add the VerveContext server

    Add a "vervecontext" entry with "url": "https://api.vervecontext.com/v1/mcp" and a headers block with "x-api-key": "vc_live_…". Keeping it in the project file means the whole team inherits the same grounding.

  3. 03

    Enable it in Cursor Settings → MCP

    Open Cursor's MCP settings to confirm the server is connected and toggle it on. The enabled sources now appear as tools available to the agent.

  4. 04

    Prompt the agent with a real-data task

    Ask Cursor to build or verify something that depends on a live value. It calls the source, grounds the step in the real number, and writes code against fact instead of a guess.

Grounding Cursor, answered.

The editor and mcp.json specifics developers ask about.

MCP setup guides →
Where do I put the config — project or global?
Either works. A project-level .cursor/mcp.json keeps the grounding scoped to one repo and shared with your team through version control; Cursor's global MCP settings apply it across every project. Most teams start project-level so a repo's grounding lives with the repo.
Does this work in agentic / composer mode?
Yes. Once the server is enabled, the sources are ordinary MCP tools, so Cursor's agent can call them during composer and agentic edit flows — not just in a side chat. That's what lets a build step check a real value before generating dependent code.
Should I commit my key to .cursor/mcp.json?
Treat the key like any secret: scope it tightly and prefer keeping the raw value out of committed files (an env reference or a per-developer local file). A scoped vc_live_… key only reaches the sources you granted, and every call lands in your usage logs.
How is this different from Cursor's built-in web search?
Web search hands the model scraped pages to interpret. VerveContext returns a typed value from a known source with its origin attached — so the agent codes against a verifiable fact rather than whatever a search result happened to say.
What shows on my bill?
VerveContext runs on APIVerve, our production data engine, so invoices and card statements read APIVERVE. Same account, same key, same rails — nothing else changes.

Build against real data. One entry in .cursor/mcp.json and the live world is a tool in your editor.

Get grounded→How grounding works

Other agents?

Claude, LangChain, or any MCP client connect the same way.

All connect guides