A ranked list of the MCP servers worth installing in Cursor, from Context7 and GitHub to Playwright and Supabase, with paste-ready configs, free options marked, the roughly 40 tool limit explained, and a workflow for generating images and video from your editor.
Cursor writes code quickly, but out of the box it knows nothing about your database schema, your open pull requests, last night's production errors, or the version of the library you installed on Tuesday. Model Context Protocol (MCP) servers close that gap by handing the agent tools it can call: query a table, read an issue, open a browser, pull the exact docs page. The catch is that every server you add also loads tool definitions into the context window, so the best setup is a short list where each server earns its slot.
This ranking sticks to servers that solve a daily problem, and it marks which ones cost nothing. The config snippets follow the formats in Cursor's MCP documentation and in each server's own repository, so you can paste them and adjust. The last sections add something most MCP lists skip: generating images and video for your project without leaving the editor.
💡 Short on time? Install Context7, GitHub and Playwright first. That trio fixes stale docs, blind repo access and untested UI, and all three have a free way in.
An MCP server is a small program, or a hosted endpoint, that exposes tools to the agent over a standard protocol. Cursor is the client. When you ask a question, the agent reads the list of available tools, decides which ones help, calls them, and uses the results in its answer. You approve calls by default, which is worth keeping on for anything that writes.
Cursor reads servers from an mcp.json file in two places:
.cursor/mcp.json in the repository root, easy to share with your team through git~/.cursor/mcp.json in your home directory, available in every projectThree transports work: stdio, where Cursor launches a local command, plus SSE and Streamable HTTP for remote servers. Local entries use command, args and env. Remote entries use url and headers, and remote servers can authenticate with OAuth. Values can reference ${env:NAME}, ${userHome} and ${workspaceFolder}, which keeps machine-specific paths and credentials out of the file. For a one-click install, the Cursor marketplace and cursor.directory both offer an "Add to Cursor" button.
💡 Put entries that rely on a personal token in the global file. Keep the project file free of credentials so it can live safely in git.
Several Cursor setup rankings report that the agent sees about 40 tools in total, counted across every active server. Each tool ships a name, a description and a JSON schema, and all of that sits in context before you type a word. One server with 30 tools can crowd out four smaller ones, and a longer menu makes the agent slower to pick the right call.
The practical rule: run three to six servers, and switch off the ones the current task does not need in Cursor's MCP settings. Servers that let you choose toolsets, like GitHub, help you stay under the limit without losing the useful parts.
These four handle the problems that show up in almost every project: wrong docs, repo context, browser testing and files outside the workspace. Each one is free to start with.
The most common AI coding failure is confident code written against an API that changed two versions ago. Context7 pulls version-specific documentation into context on demand. It exposes two tools, resolve-library-id to turn a library name into an ID and query-docs to fetch the relevant pages, so the cost in tool definitions stays tiny.
The hosted server works without a token, and a free token from the Context7 dashboard raises the rate limits. Add the phrase "use context7" to a prompt, for example: "Build a route handler with the current Next.js caching options. use context7."
{
"mcpServers": {
"context7": {
"url": "https://mcp.context7.com/mcp",
"headers": {
"Authorization": "Bearer ${env:CONTEXT7_TOKEN}"
}
}
}
}
Drop the headers block if you want to start with no account at all.
GitHub's official server lets the agent read and act on your repositories: search code, triage issues, open pull requests and read CI results. It is MIT licensed, and the hosted version lives at https://api.githubcopilot.com/mcp/.
You can sign in with OAuth in clients that support it, or pass a personal access token as a header. With no toolsets specified it loads a default group covering context, repos, issues, pull requests and users, which already helps with the tool ceiling. A read-only mode skips every write tool.
{
"mcpServers": {
"github": {
"url": "https://api.githubcopilot.com/mcp/",
"headers": {
"Authorization": "Bearer ${env:GITHUB_PAT}"
}
}
}
}
Create the token with the narrowest scopes you can get away with. A fine-grained token limited to the repositories you actually work in is safer than a classic token with full access.
Microsoft's Playwright MCP lets the agent drive a real browser: open a page, click, fill forms, and check what happened. It works from the accessibility tree rather than pixels, so it needs no vision model and keeps token use low. It runs locally under the Apache-2.0 license.
{
"mcpServers": {
"playwright": {
"command": "npx",
"args": ["@playwright/mcp@latest", "--headless"]
}
}
}
Without --headless the browser opens visibly, which is handy when you want to watch the agent work, so delete the flag while you are testing. Use --browser to pick Chrome, Firefox, WebKit or Edge. A strong first prompt: "Start the dev server, open the sign-up page, submit an empty form, and report every console error."
Cursor already reads your workspace, so the Filesystem server only matters for folders outside it: a shared specs directory, a design export folder, a notes vault. It is a free reference server from the MCP project, and you give it an explicit list of allowed directories as arguments.
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "${userHome}/Documents/specs"]
}
}
}
List only directories you are comfortable letting an agent read and change. If you have no folders outside the repo, skip this one and save the tool slots.
Once the basics work, add servers that connect the agent to the systems your code actually talks to. These three are the ones that come up most often in real projects.
The hosted Supabase server at https://mcp.supabase.com/mcp bundles more than 20 tools: table design, migrations, SQL queries, database branching and TypeScript type generation. Sign-in happens in the browser through OAuth, and you scope it to one project with a project_ref parameter. The platform has a free plan, so you can try it with a side project.
{
"mcpServers": {
"supabase": {
"url": "https://mcp.supabase.com/mcp?project_ref=YOUR_PROJECT_REF&read_only=true"
}
}
}
Point it at a development project, not production, and start read-only. Remove read_only=true only when you want the agent running migrations.
Sentry's server at https://mcp.sentry.dev/mcp signs in through the browser and brings stack traces, release data and issue details straight into the chat. Instead of pasting an error from a dashboard, you ask the agent to fetch the newest unresolved issue in a project, read the failing file and propose a fix. You need a Sentry account, and the free plan is enough to try the workflow.
Figma's Dev Mode server runs locally at http://127.0.0.1:3845/mcp and turns selected frames into code with real spacing, colors and component names. It needs the Figma desktop app and a paid seat with Dev Mode, so it is the one entry here that is not a free pick. Add it only if you convert design frames to code every week.
Here is the whole list in one table, with what each server costs and how it signs in. Prices and allowances change, so confirm on the project's page before you commit a team to anything.
| Server | Cost | Sign-in | Best for |
|---|---|---|---|
| Context7 | Free tier | Optional token | Version-correct docs |
| GitHub | Free server, MIT license | OAuth or token | Pull requests, issues, code search |
| Playwright | Free, Apache-2.0 | None | UI checks and end-to-end tests |
| Filesystem | Free | None | Folders outside the repo |
| Sequential Thinking | Free | None | Planning multi-step tasks |
| Supabase | Free platform plan | Browser OAuth | Postgres and migrations |
| Sentry | Free plan | Browser OAuth | Production debugging |
| Brave Search | Free monthly allowance (about 2,000 queries at the time of writing) | Token required | Web search |
| Figma | Paid seat | Dev Mode | Design to code |
If you want a single file to start from, this one wires up the three picks that need no account beyond GitHub. Paste it into ~/.cursor/mcp.json and set GITHUB_PAT in your shell first.
{
"mcpServers": {
"context7": { "url": "https://mcp.context7.com/mcp" },
"github": {
"url": "https://api.githubcopilot.com/mcp/",
"headers": { "Authorization": "Bearer ${env:GITHUB_PAT}" }
},
"playwright": {
"command": "npx",
"args": ["@playwright/mcp@latest", "--headless"]
}
}
}
MCP only helps if the model behind Cursor chooses the right tool, passes sensible arguments and stops when it has the answer. That behavior varies a lot between models, and it changes with every release, so treat any leaderboard with suspicion and test on your own repo.
A fair test is one task that needs three or four tool calls in order: "Find the newest failing CI run, open the file named in the log, and propose a fix." Watch for four things: wrong tool picked first, repeated identical calls, invented arguments, and a final answer that ignores the tool output.
These are the models worth putting through that test, assuming your Cursor plan exposes them:
My starting point is a fast model for quick doc and repo lookups and a stronger one for chains of five or more calls, then adjusting after a week of real use. You can also paste the same planning prompt into each of these models on Picasso IA to compare how they sequence a tool plan before you switch the one in your editor.
Docs sites, landing pages, README banners, empty states and changelog posts all need visuals, and the usual routine is leaving the editor, generating something elsewhere, renaming the file and dragging it into the repo. A generation API turns that into a prompt, a script and a committed file.
When an image sits in the same pull request as the component that uses it, reviewers see both together and nothing goes missing. It also lets you regenerate a hero image in the same session where you changed the headline.
Picasso IA exposes four models through its developer API: Picasso IA Image for text-to-image, Picasso IA Image Editor Pro for editing and combining images, Picasso IA Video for video from text or an image, and Seedance 2.5 Lite for video with synchronized audio. The account area also lists MCP connections, but the server details sit behind sign-in, so check there for the exact URL before adding it to mcp.json.
Start in the browser to find a prompt that works, then move it into a script.
curl -X POST https://api.picassoia.com/v1/models/picassoia/picassoia-image/predictions \
-H "Authorization: Bearer $PICASSOIA_TOKEN" \
-H "Content-Type: application/json" \
-d '{"input":{"prompt":"a developer desk in morning light, photorealistic","aspect_ratio":"16:9"}}'
curl https://api.picassoia.com/v1/predictions/PREDICTION_ID \
-H "Authorization: Bearer $PICASSOIA_TOKEN"
Tokens start with pia_sk_ and are created in your account's API section, with a cap of two per account. An account can run five predictions at once, shared across tokens and MCP connections. According to the API docs, predictions are free of credits, but creating them requires an Infinite plan, and other plans get a 403 plan_required response. Check your plan before wiring this into a build step.
💡 Save generated files into
public/images/with descriptive names, then ask the agent to add the<img>tag with proper alt text. Descriptive file names and alt text help search traffic.
A five-second clip beats a static screenshot for a changelog entry or a feature page. Picasso IA Video animates a still, so you can take the hero image from the step above and give it gentle camera motion. Seedance 2.5 Lite adds synchronized audio, and its page advertises clips up to 10 seconds.
Write video prompts chronologically: where the subject starts, what moves, and how the camera travels. For example, "A laptop on a wooden desk at dawn, slow dolly in toward the screen, steam rising from a mug at left, soft window light." Compress the result before committing it, since video files grow a repository quickly.
Most bad MCP setups fail in the same few ways. Fix these before you add anything new.
Fifteen servers sound powerful and behave badly. Tool descriptions overlap, the agent hesitates between near-identical options, and you pay for the schemas on every request. Add one server, use it for a week, and keep it only if the agent reaches for it unprompted.
A project-level mcp.json usually gets committed. A token pasted into it ends up in git history, and removing it later does not make the old value safe. Use ${env:NAME} references, or the envFile option for local servers, and rotate any token that has ever been committed.
Read-only first is a good habit. GitHub supports a read-only mode, and Supabase accepts read_only=true. Keep tool approval on for anything that writes, merges, deletes or runs SQL. For community servers outside the official ones, read the source before installing, pin a version instead of @latest when the server touches sensitive systems, and prefer servers with an active maintainer and a clear license.
You do not need all of this today. Install Context7, add GitHub with a narrow token, and let Playwright check one real page. Then take the next hero image, banner or demo clip your project needs and make it yourself: write a prompt on Picasso IA Image, refine it with Image Editor Pro, and turn the best frame into motion with Picasso IA Video. Change one detail per attempt, such as the light direction or the lens, and you will quickly see which prompts earn a place in your repo. The whole catalog is waiting at picassoia.com/en/all-models.
