Getting the most out of Cursor isn’t just about which model you pick — it’s the combination of model choice, Project Rules, context management, and MCP integrations that determines whether Cursor helps or frustrates. Here’s what every setting actually does and how to configure each one for reliable, high-quality results.
Choosing the Best Model in Cursor 2026
Cursor gives you access to a wide range of AI models through its Pro subscription, plus the ability to add custom models via BYOK (bring your own API key). The right model depends on what you’re trying to do.
Cursor’s Available Models (June 2026)
Models available through Cursor Pro at the time of writing:
- Claude Sonnet 4.5 — Cursor’s primary default model; strong balance of speed, quality, and cost. The model most users run most of the time
- Claude Opus 4.7 and 4.8 — Anthropic’s most powerful reasoning models; best for complex multi-step problems, architecture-level decisions, and tasks requiring the strongest planning ability. Slower and draws more from the credit pool
- GPT-5 and GPT-5.5 — OpenAI’s frontier models; GPT-5.5 is the stronger of the two for agentic coding tasks
- GPT-5.3 Codex — a coding-specialized variant from OpenAI’s family; purpose-built for code generation
- Gemini 2.5 Pro and Gemini 3.1 Pro — Google’s frontier models; Gemini 2.5 Pro has a very long context window, which is useful for tasks involving large files or many files in context simultaneously
- Grok Build 0.1 — xAI’s coding-specialized variant; newer entry in Cursor’s model list
- Cursor’s in-house models (Composer / Fusion) — proprietary models tuned for speed and editor integration; these power Tab completions and are optimized to feel instant inside the IDE
- Auto mode — Cursor’s managed routing mode, which selects the most appropriate model for each task automatically; Auto often queues requests differently during high-load periods and doesn’t draw from the credit pool the same way as manual model selection
Which Model Should You Use?
- For everyday coding tasks and Tab completions: Auto mode or Claude Sonnet 4.5 — fast, accurate for most work, credit-efficient
- For complex bugs, architecture decisions, and multi-file refactors: Claude Opus 4.7/4.8 or GPT-5.5 — the extra reasoning power is worth the cost for genuinely difficult problems
- For long-context tasks (many large files in context): Gemini 2.5 Pro or 3.1 Pro — the extended context window handles large codebases more reliably
- For privacy-sensitive code: DeepSeek hosted by Cursor (not via external API) or a local model — avoids routing code through external providers
- If output quality degrades: switch providers rather than retrying. If Claude is producing poor results on a given task, try GPT — and add more @-context rather than repeating the same prompt
About Claude 3.7 and ‘Cursor No Claude 4’
Searches for ‘cursor claude 3.7’ and ‘cursor no claude 4’ reflect questions about specific model versions. Claude 3.7 Sonnet was a previous generation model — current Claude models in Cursor are the Claude 4.x family (Sonnet 4.5, Opus 4.6, 4.7, 4.8). If you don’t see Claude Opus 4 in your model picker, it may require Max Mode or a higher usage tier — Claude Opus models draw significantly more from the credit pool than Sonnet, and Cursor may gate access based on your plan.
Cursor Project Rules: The .cursorrules and .mdc Files
Project Rules are instructions that Cursor’s AI reads before every conversation in a given project. They define the AI’s role, what it’s allowed to do, and how it should behave. Getting Project Rules right is the single highest-leverage configuration change most Cursor users can make.
Where to Put Project Rules
Cursor supports two formats for project-level rules:
- .cursorrules file in your project root (the older format, still supported but being deprecated in newer Cursor versions)
- .cursor/rules/*.mdc files — Modular Rule Definition files, the current recommended format. You can have multiple .mdc files for different aspects of project behavior
- CLAUDE.md — Cursor also reads CLAUDE.md files, which serves as a project constitution that both Cursor and other AI tools (like Claude Code) recognize
Changes to rules files take effect on the next chat session or after reloading Cursor.
Essential Rules Every Project Should Have
The developer community has converged on several rules that dramatically improve Cursor’s behavior:
1. Role and tool permission definition:
You are an AI coding assistant working inside the Cursor IDE.
You can view, edit, create, and run files within the project directory.
Use edit_file to edit existing files. Use create_file to create new files.
Do not ask the user to perform file actions manually — use the tools.
2. Interface Freeze rule (prevents agents from writing sprawling implementations):
Do not add new components, routes, or major features without explicit approval.
If a task would require changes beyond the immediate request, stop and describe
what additional changes would be needed before proceeding.
3. Anti-Hallucination rule (prevents importing packages that don’t exist):
Before importing any package or library, verify it exists in package.json (Node)
or requirements.txt (Python). Do not import packages that are not listed as
dependencies. If a package is needed, ask before adding it.
4. Coding style preferences (adapt to your stack):
Use TypeScript strict mode. Prefer functional components over class components.
Use early returns to avoid nested conditionals. Write comments for non-obvious logic.
5. Workflow rules:
Always make a defensive git commit before starting any large refactor or agent operation.
Suggest a checkpoint commit if a task involves changes to more than 3 files.
Why Cursor Doesn’t Follow Your Rules
‘Cursor doesn’t follow rules’ is a common frustration with a few specific causes:
- Rules file not being read: Verify your .cursorrules or .mdc file is in the right location (project root for .cursorrules, inside .cursor/rules/ for .mdc files). Start a new chat session after making changes — rules are applied at session start, not mid-conversation
- Rules too vague: ‘Be concise’ is too abstract. ‘Keep responses under 100 words unless explicitly asked for more’ is actionable. Specific, concrete instructions are followed more reliably than general guidance
- Context overriding rules: If you’re using @-context mentions or sharing very long code, the sheer amount of content can push the rules section out of the model’s effective attention. Keep rules focused and front-load the most important instructions
- Model-specific behavior: Some models follow instructions more precisely than others. If Claude is not following your rules, try GPT or vice versa on the same prompt
Context7 MCP: Using cursor rules use context7
Context7 is a Model Context Protocol (MCP) server that solves one of the most common problems with AI coding tools: outdated or hallucinated API documentation. When you ask Cursor to use a library or framework, it draws on training data that may be months or years old — leading it to suggest deprecated APIs, old function signatures, or methods that were renamed in recent library versions.
Context7 pulls real-time documentation for over 2,000 libraries directly into Cursor’s context when you mention a package. The result is that Cursor generates code based on the current version of the library, not the version in its training data.
How to Set Up Context7 in Cursor
- Open Cursor Settings (Cmd+, on Mac, Ctrl+, on Windows)
- Navigate to the MCP section (Tools & Integrations > MCP in recent Cursor versions)
- Add a new MCP server with Context7’s configuration (available at context7.com)
- Once added, Context7 activates automatically when Cursor’s agent is working with recognized packages
The ‘cursor rules use context7’ search reflects developers adding an explicit Project Rule instructing Cursor to use the Context7 MCP server for library lookups. A typical rule for this:
When working with any library or framework, use the Context7 MCP to fetch
current documentation before generating code that uses that library’s API.
Context7 is considered by many developers to be the single most impactful MCP addition to a Cursor setup, particularly for projects using frequently-updated libraries like React, Next.js, shadcn/ui, or any actively developed framework.
How to Add DeepSeek to Cursor Agent Mode
DeepSeek V4 Pro and V4 Flash are popular custom model additions to Cursor because of their cost efficiency. DeepSeek V4 Pro costs approximately $1.74 per million input tokens — dramatically cheaper than frontier models like Claude Opus or GPT-5.5, while remaining competitive on coding tasks.
DeepSeek Setup in Cursor (June 2026)
- Open Cursor Settings > Models > Custom Models (or Cursor Settings > AI > Custom Models depending on your Cursor version)
- Click ‘Add Model’ and fill in the fields: Name: DeepSeek V4 Pro; Base URL: https://api.deepseek.com/v1; API Key: your DeepSeek API key from platform.deepseek.com; Model string: deepseek-v4-pro (or the current V4 model identifier)
- Save settings and the model will appear in Cursor’s model picker
Important: The legacy model aliases deepseek-chat and deepseek-reasoner are being retired on July 24, 2026. If you set up DeepSeek before that date using those aliases, update your configuration to use the V4 model names before the deadline — after July 24, the legacy aliases will stop routing correctly.
DeepSeek V4 Flash is the faster, cheaper tier within DeepSeek V4. For most everyday coding sessions — routine edits, refactoring, explanations — Flash covers the work at a fraction of V4 Pro’s cost. Use V4 Pro for complex reasoning tasks where quality matters more than cost.
GPT-4.1 Keeps Stopping
GPT-4.1 is a lighter model available on free and early Pro tiers. If it keeps stopping mid-generation, the most common causes are: hitting the model’s output token limit for a single response (reduce the scope of what you’re asking in one prompt), approaching your monthly usage limit (switch to Auto mode or a cheaper model), or rate limiting on your account (wait a moment and retry). Splitting large tasks into smaller steps typically resolves generation stops.
Does Cursor AI Track Memory Across Conversations?
No — Cursor does not maintain memory between separate chat sessions by default. Each new chat starts with a blank context, aware only of:
- Your Project Rules (.cursorrules, .mdc files, CLAUDE.md) — these persist across sessions because they’re files in your project
- Files you actively mention with @-context (@file, @codebase, @folder, @docs)
- The current file open in your editor
There is no automatic session memory that carries your preferences or previous conversation context into a new chat. This is a deliberate design choice — cross-session memory introduces significant privacy and confidentiality considerations for code.
Workarounds for Persistent Context
- Project Rules as memory: Put anything you want Cursor to always know in .cursorrules or .mdc files. Team conventions, architecture decisions, component patterns, and library preferences all belong here
- CLAUDE.md / memory.md: Create a markdown file in your project that the AI reads at the start of sessions. Periodically update it with important context from previous sessions
- Session kickoff prompt: Start each new chat with a brief context line: ‘We’re building a Next.js app, using Prisma for the database, currently working on the authentication flow.’ This takes 10 seconds and eliminates the blank-context problem
- @codebase: Using @codebase at the start of a question gives Cursor semantic search access to your entire codebase, effectively providing project context without explicit memory
Cursor Hotkeys Reference
Essential keyboard shortcuts for Cursor (Windows Ctrl = Mac Cmd):
- Cmd/Ctrl + K: Inline edit — opens an AI input field in-line with your code to make targeted edits to a selection
- Cmd/Ctrl + L: Open chat panel — starts or focuses the Cursor chat sidebar
- Cmd/Ctrl + I: Open Composer / Agent mode — the multi-file autonomous agent mode
- Tab: Accept autocomplete suggestion — accept the current Tab completion in-line
- Escape: Reject autocomplete suggestion — dismiss the current Tab completion
- Cmd/Ctrl + Shift + L: Add selection to chat — adds the highlighted code to the active chat as context
- Cmd/Ctrl + Shift + J: Toggle chat panel visibility
- Cmd/Ctrl + /: Toggle comment (standard VS Code shortcut, works in Cursor)
- Cmd/Ctrl + P: Quick file open (standard VS Code shortcut, works in Cursor)
Cursor also inherits all standard VS Code keyboard shortcuts, which can be viewed and customized in File > Preferences > Keyboard Shortcuts (or Cmd/Ctrl+Shift+P > ‘Open Keyboard Shortcuts’).
How to Revert to a Previous Chat State in Cursor
Cursor has a Checkpoint and Revert feature designed to let you undo the changes an agent makes to your files. However, there is a known bug in versions 2.4 through approximately 2.6.x: the Review Tab must be closed before using ‘Fix in Chat’ — if the Review Tab is open, the revert system can create file conflicts.
The most reliable practice for recovering from unwanted agent changes:
- Before any agent operation, make a defensive git commit: git commit -am ‘checkpoint before agent’ — this gives you a hard rollback point independent of Cursor’s internal state
- After an agent operation produces bad results, use Cursor’s built-in Checkpoint revert to undo the session’s file changes
- If the revert doesn’t work cleanly (due to the Review Tab bug), use git checkout — . or git reset HEAD –hard to revert to your last commit
- Update Cursor to the latest version — the revert bug behavior has been improved in recent releases
Cursor Promo Codes: What’s Actually Available
Cursor does not routinely publish discount or promo codes in the traditional sense. Most websites listing ‘Cursor promo codes’ are affiliate sites whose codes either don’t work or redirect to standard pricing. The legitimate ways to pay less for Cursor are:
- Annual billing: 20% discount on any paid tier — Pro becomes ~$16/month effective instead of $20
- Student program: One full year of Pro free for students with a verified .edu email through SheerID at cursor.com/students
- BYOK: Connect your own API key, bypass Cursor’s credit system, and pay model providers directly — potentially cheaper for light users
Frequently Asked Questions
What is the best model to use in Cursor in 2026?
For most developers, Claude Sonnet 4.5 (Cursor’s default) or Auto mode handles the majority of coding tasks well. For complex problems and multi-file refactors, Claude Opus 4.7/4.8 or GPT-5.5 are the strongest options. For long-context work with large codebases, Gemini 2.5 Pro’s extended context window is an advantage.
How do I use Context7 with Cursor?
Add Context7 as an MCP server in Cursor Settings > MCP. Then add a Project Rule instructing Cursor to use Context7 for library documentation lookups. Context7 pulls real-time docs for 2,000+ libraries, preventing outdated API hallucinations.
How do I add DeepSeek to Cursor?
Go to Cursor Settings > Custom Models and add DeepSeek’s API endpoint (api.deepseek.com/v1) with your DeepSeek API key. Use the V4 model names rather than the legacy deepseek-chat alias, which is being retired on July 24, 2026.
Does Cursor remember previous conversations?
No — Cursor starts each chat session fresh with no memory of previous conversations. Use Project Rules (.cursorrules or .mdc files), CLAUDE.md, and @-context mentions to provide persistent context across sessions.
What are the main Cursor hotkeys?
Key shortcuts: Cmd/Ctrl+K (inline edit), Cmd/Ctrl+L (open chat), Cmd/Ctrl+I (Agent mode), Tab (accept suggestion), Escape (reject suggestion), Cmd/Ctrl+Shift+L (add to chat). Cursor also inherits all VS Code keyboard shortcuts.
Final Thoughts
The difference between a developer who finds Cursor transformative and one who finds it frustrating usually comes down to configuration: Project Rules that give the AI clear instructions, Context7 to prevent library hallucinations, the right model for the right task, and a git commit habit before any large agent operation. None of these take more than 30 minutes to set up, and the productivity difference is substantial. Start with a solid .cursorrules file, add Context7 as your first MCP, and let Auto mode handle model selection until you have a specific reason to override it manually.
