# Billing
Source: https://docs.cursor.com/account/billing
Complete guide to managing Cursor billing: subscriptions, refunds, cycles and access through Stripe portal
We use Stripe as our billing and payments provider
### How do I access billing settings?
The billing portal is where you'll manage all aspects of your subscription. You can access it through the [dashboard](https://cursor.com/settings) by clicking the "Billing" button in your account settings. This takes you to a secure portal where you can handle all billing-related tasks.
### What are Cursor's billing cycles?
Billing cycles run on either a monthly or annual basis, starting on the day you subscribe. For Business accounts with multiple seats, we use prorated billing when your team size changes. This means you only pay for the actual time each seat is used within a billing cycle.
### How do team seats work for Business accounts?
Business accounts use a per-seat billing model where each team member requires one seat license. When adding new members mid-cycle, you're only charged for their remaining time in that billing period. Team admins can manage seats directly through the dashboard.
### Can I switch between monthly and annual billing?
Yes you can! Here's how:
**Pro plan**
1. Go to [settings](https://cursor.com/settings)
2. Click on "Manage subscription" and you will be taken to the billing portal
3. Click on "Update subscription"
4. From here you can switch between monthly and annual billing
5. Select "Yearly" or "Monthly", then click on "Continue"
**Business plan**
1. Go to [settings](https://cursor.com/settings)
2. In the account section, click on "Advanced" then "Upgrade to yearly billing"
Please note that you can only switch from monthly to yearly billing
self-serve. To switch from yearly to monthly billing, please contact us at
[hi@cursor.com](mailto:hi@cursor.com).
### Where can I find my invoices?
All your billing history is available in the billing portal, where you can view and download both current and past invoices.
### Can I get invoices automatically emailed to me?
Currently, invoices need to be downloaded manually from the billing portal. We know this is a hassle, so we're developing automatic invoice emails as a new feature, and once available, you'll be able to opt-in!
### How do I update my billing information?
You can update your payment method, company name, address, and tax information through the billing portal. We use Stripe as our payment processor to ensure secure transactions. Please note that changes to billing information will only affect future invoices - we cannot modify historical invoices.
### How do I cancel my subscription?
You can cancel your subscription directly through the billing portal using the "Cancel subscription" button. Your access will continue until the end of your current billing period.
### I'm having other billing issues. How can I get help?
For any billing-related questions not covered here, please email us at [hi@cursor.com](mailto:hi@cursor.com). Include your account details and specific concerns, and our team will help you resolve them quickly!
### Can I get a refund?
You can self-serve a refund by going to the billing portal and clicking on the `Cancel subscription` button. Our self-serve refund policy is as follows:
**EU, UK or Turkey customers**
* Eligible for a refund if you cancel your subscription within 14 days of purchase.
**All other customers (US + rest of world)**
* Monthly subscriptions: Refundable within 24 hours after purchase.
* Annual subscriptions: Refundable within 72 hours after purchase
If you're not in the window of self-serve refunds, reach out to us at [hi@cursor.com](mailto:hi@cursor.com) and we'll help you!
# Dashboard
Source: https://docs.cursor.com/account/dashboard
Learn how to manage billing, usage pricing, and team settings in the dashboard for different plans
You can view the Cursor dashboard by going to [cursor.com/settings](https://cursor.com/settings)
From the dashboard you can access billing portal, setup usage based pricing and manage your team. Depending on if you're on Free, Pro or Business, you'll see different sections.
## Pro
From here you can access billing portal, setup usage based pricing and see how many requests you have left.
## Business
Business will have a section for teams.
### Team
Read more about how to manage teams in [members](/account/teams/members)
### Metrics
Read more in [team analytics](/account/teams/analytics). This is only available for teams
### Usage based pricing
This is where you can toggle usage based pricing and set spending limits. Read more about [usage based pricing](/account/plans-and-usage) and how to configure it
# Plans & Usage
Source: https://docs.cursor.com/account/plans-and-usage
Guide to Cursor usage tiers, request types, quotas, and billing options for premium models and team accounts
To view your current usage, you can visit the dashboard at [cursor.com/settings](https://cursor.com/settings)
## Available Plans
- 50 slow `premium` model uses per month
- 2000 [completions](/tab/overview)
- 500 fast `premium` requests per month
- Unlimited slow `premium` requests per month
- Unlimited [completions](/tab/overview)
- 10 o1-mini per day
- Same usage as Pro
- Enforces privacy mode
- Centralized team billing
- Admin dashboard with usage stats
- SAML/OIDC SSO
- Unlimited [completions](/tab/overview)
For costs and more pricing info, please visit the [Cursor Pricing](https://cursor.com/pricing) page.
## Understanding Usage
### Fast and Slow Requests
There are two types of requests in Cursor, **slow** and **fast** that has its own pool.
By default, Cursor servers try to give all users fast `premium` model requests. However, when users run out of fast `premium` credits, they are moved to a slow pool. Wait times in the slow pool are calculated proportionally to how many slow requests you've used, so they generally remain manageable unless you're well over your fast request limit.
To bypass wait times entirely, you can enable usage-based pricing (you'll only be charged for requests beyond your included fast requests).
See [models](/settings/models) for an overview of which models are `premium` and their alternatives.
### Included Requests
Every subscription includes a set amount of fast requests. The number of included requests depends on your plan as shown in the plan comparison above.
### Additional Requests
We offer usage-based pricing for additional requests beyond your plan's included quota:
#### Usage-based Pricing
You may opt in to usage-based pricing for requests that go beyond what is included in your Pro or Business plan from your [dashboard](/account/dashboard).
Usage-based pricing is only available with a paid subscription.
From the dashboard, you can toggle usage based pricing for `premium` models and `other` models (see [models](/settings/models) to understand which model is which). You can also configure a spend limit in USD to make sure you never go over that. Once the spending limit is hit, slow requests will be used.
We will bill for additional fast requests when you've made requests totaling \$20, **or** on the 2nd or 3rd day of the month, whichever comes first.
375 fast requests made with a `premium` model (\$15) will be billed at the beginning of the next month since the total value is under \$20
1150 fast requests made with a `premium` (\$46) will be billed 3 times:
1. When first batch of 500 requests has been made (\$20)
2. When second batch of 500 requests has been made (also \$20)
3. Beginning of next month (remaining \$6)
For team accounts, administrators can restrict usage-based pricing settings to admin-only access.
Cost per request for each model can be found on the [models](/settings/models) page.
#### Fast Requests Packages
Fast requests packages have been deprecated in favor of usage-based pricing. Existing users with additional packages can continue to use them and have the option to remove them, but new packages cannot be purchased.
Fast Request Packages were bundles of 500 requests that could be purchased in addition to your plan's included quota. These have been replaced by usage-based pricing for fast requests, as purchasing them in bundles often meant users would pay for requests they didn't use.
### FAQ
#### When do my fast requests reset?
Your Fast Requests reset on a fixed monthly date based on when you first set up your plan. If you purchase additional requests (for example, upgrading from 500 to 1000 requests), the reset date remains unchanged. For instance, if your plan started on the 23rd, your requests will always reset on the 23rd of each month, regardless of when you purchase additional requests.
#### What does "500 premium requests" mean for teams?
Each user gets their own quota of 500 fast requests for premium models per month. These requests are not pooled across the team - every team member gets their own fresh 500 requests when their personal monthly cycle resets.
# Pricing
Source: https://docs.cursor.com/account/pricing
# Privacy & Security
Source: https://docs.cursor.com/account/privacy
Guide to Cursor's privacy settings, data handling, and code indexing with Privacy Mode option
Cursor is built with privacy and security at its core. We have built Cursor from the ground up to give you the peace of mind that your code and data is private and secure.
## Quick Links
To learn more about Cursor's privacy and security practices, please see the following links:
Read our comprehensive privacy policy to understand how we handle your data
Learn about our security practices and how we protect your code
View our Trust Center to learn more about our security practices and to access our SOC2 certification. security reports and annual penetration testing reports.
## Privacy FAQs
### What is Privacy Mode?
With `Privacy Mode` enabled, none of your code will ever be stored by us or any third-party. Otherwise, we may collect prompts, code snippets and telemetry data to improve Cursor. You can [read more about Privacy Mode here](https://cursor.com/privacy). Privacy mode is enforced for Business plans
You can enable `Privacy Mode` at onboarding or under `Cursor Settings` > `General` > `Privacy Mode`.
### Are requests always routed through the Cursor backend?
Yes! Even if you use your API key, your requests will still go through our backend. That's where we do our final prompt building.
### Does indexing the codebase require storing code?
It does not! If you choose to index your codebase, Cursor will upload your codebase in small chunks to our server to compute embeddings, but all plaintext code ceases to exist after the life of the request.
The embeddings and metadata about your codebase (hashes, obfuscated file names) are stored in our database, but none of your code is.
You can read more about this on our [security page](https://cursor.com/security).
# Analytics
Source: https://docs.cursor.com/account/teams/analytics
Track team metrics including usage stats, per-user activity, and active user counts from the dashboard
Team admins can track metrics for their team from the [dashboard](/account/dashboard).
A new and upgraded metrics page is currently in development, including an API for programmatic data retrieval and will be available soon.
The metrics dashboard shows usage statistics for your team over the last 30 days:
### Total Usage
View aggregate metrics across your entire team, including total tabs and premium requests used. For teams less than 30 days old, metrics reflect actual usage since team creation, including activity from team members' individual accounts prior to joining.
### Per Active User
See average usage metrics per active user, including tabs accepted, lines of code, and premium requests.
### User Activity
Track both weekly and monthly active user counts.
## FAQ
The difference in numbers you're seeing is because the team tab shows requests for the current billing period, while the metrics page shows a rolling 30-day window. We know is can be confusing - we're working on making this clearer in the dashboard.
# Members + Roles
Source: https://docs.cursor.com/account/teams/members
Learn about team roles, member management, SSO options, usage controls and billing for organizational teams
Within a Cursor team, you can have three different roles.
**Click on a role below to learn more about it.**
Standard team member with access to all Business features
Full team management and security control capabilities
Admin capabilities without using a paid seat
## Roles
### Member
Members are the default role for team members with access to Cursor's Pro features.
Full access to all **Pro features** including 500 premium requests and unlimited completions
Each member uses **one billable seat** and counts towards the total renewal of your team each month / year
Members have **no access** to the billing settings or the admin dashboard.
### Admins
Admins have comprehensive control over team management and security settings to ensure smooth team operations.
Full access to all **Pro features** as normal members
Add and remove members, modify roles, and setup SSO
Configure usage-based pricing and set spending limits for the team
### Unpaid Admin
Unpaid Admins manage the team without using a paid seat - ideal for IT or finance staff, who don't need Cursor access.
Unpaid Admins are **not billable**, and do not have any Pro features
Add and remove members, modify roles, and setup SSO
Configure usage-based pricing and set spending limits for the team
Unpaid Admins are required to have at least one paid user on the team.
## Role Comparison
| Capability | Member | Admin | Unpaid Admin |
| ---------------------- | :----: | :---: | :----------: |
| Use Cursor features | ✓ | ✓ | |
| Invite members | ✓ | ✓ | ✓ |
| Remove members | | ✓ | ✓ |
| Change user role | | ✓ | ✓ |
| Admin dashboard | | ✓ | ✓ |
| Configure SSO/Security | | ✓ | ✓ |
| Manage Billing | | ✓ | ✓ |
| Set usage controls | ✓ | ✓ | ✓ |
| Requires paid seat | ✓ | ✓ | |
## Managing members
All members in the team can invite other members. We currently do not have any way to control invites.
### Add member
Members can be added in three ways:
\- Click the `Invite Members` button
\- Enter email addresses
\- Users will receive an email invite to join the team
\- Click the `Invite Members` button
\- Copy the `Invite Link`
\- Share with team members
\- Configure SSO in the [admin dashboard](/account/teams/sso)
\- Users will be automatically added to the team when they login via their SSO-enabled email address
Invite links do not expire and anyone who gets access to the link can join a
team.
You can prevent this by setting up [SSO](/account/teams/sso)
### Remove member
Admins can remove members at any time by clicking the context menu and then "Remove". We'll only charge for time the member was in the team, and any pro-rated credit earned from removing a member mid-plan will be applied to your next invoice.
### Change role
Admins can change roles for other members by clicking the context menu and then use the "Change role" option.
There must be at least one Admin, and one paid member on the team at all times.
## Security & SSO
SAML 2.0 Single Sign-On (SSO) is available on Business and Enterprise plans. Key features:
* Configure SSO connections ([learn more about SSO setup](/account/teams/sso))
* Set up domain verification
* Automatic user enrollment through SSO
* SSO enforcement options
* Identity provider integration (Okta, etc)
## Usage Controls
Access usage settings to:
* Enable usage-based pricing
* Enable for usage-based for premium models
* Set admin-only modifications for usage-based pricing settings
* Set monthly spending limits
* Monitor team-wide usage
## Billing
When adding new team members:
* Each new member or admin adds a billable seat (see [pricing](https://cursor.com/pricing))
* Seat changes are prorated for your billing period
* Unpaid admin seats are not counted
When adding new team members in the middle of a month, we'll only charge you for the days they actually use. Similarly, if someone leaves the team, we'll credit your account for any unused days.
If you change someone's role (e.g from Admin to Unpaid Admin), we'll automatically adjust the billing from the day of the change. You can choose to be billed either monthly or yearly - both options are available to suit your needs.
Your monthly or yearly renewal will always occur on the same day as when you first signed up, regardless of additional or removed members.
### Switch to Yearly billing
You can save **20%** of the Business plan by switching from monthly to yearly billing. This can be done from the [dashboard](/account/dashboard)
1. Go to [settings](https://cursor.com/settings)
2. In the account section, click on "Advanced" then "Upgrade to yearly billing"
Please note that you can only switch from monthly to yearly billing via the dashboard. To switch from yearly to monthly billing, please contact us at [hi@cursor.com](mailto:hi@cursor.com).
# Get Started
Source: https://docs.cursor.com/account/teams/setup
Guide to create and manage Cursor business teams with SSO, enterprise features, and MDM deployment options
## Cursor for Business
Cursor was built with versatility in mind, and can be used from hobby projects to large scale enterprise applications. For the best experience, we have built a Business plan that enhances the Cursor application for teams!
Alongside the Cursor application, we have built a suite of tools to help you manage your team, including SSO, team management, and more.
## Creating a Team
To get started with Cursor for your team, you can create a team by following the steps below.
To create a team, you need to be on the [Business plan](/account/plans-and-usage). To get started, you can choose one of the following options:
If you are new to Cursor, click here to create a new account and team
If you are already on a Pro plan, you can click the "Upgrade to Business" button in dashboard
After clicking "New Team", enter the details for the team. You will have to
select name and billing cycle for the team
After the team is created, you can start inviting members to the team. All
changes to users are prorated, meaning that we will only charge for the time
that a user has been a member of the team
After the team is created, you can enable [SSO](/account/teams/sso) for the team for additional security and easy onboarding for new members of your team.
## FAQ
### My team uses ZScalar / a proxy / a VPN, will Cursor work properly?
Cursor uses HTTP/2 to provide the best experience, and unfortunately some proxies and VPNs block this.
To resolve this, you can enable the HTTP/1.1 fallback in the app settings. This will force Cursor to use HTTP/1.1, which is not blocked by most proxies and VPNs.
We hope to add automatic detection and fallback in the future!
### How can I purchase licenses for my company?
Cursor is billed on a per-user basis, and does not have a fixed amount of seats. You can invite as many or as few users as you'd like to your team, and you will only be charged for the amount of users in your team.
If you add or remove users from your team, the billing will be updated immediately, and you will either be charged or refunded accordingly. Refunds are done as account credit, so will be automatically applied to your next invoice.
For simplicity, we keep your renewal date on the same day each month/year, and any mid-plan changes are prorated.
### How can I set up a team when I'm not going to use Cursor myself?
As part of our business management tools, you can now set members of your team to be [Unpaid Admins](/account/teams/members).
This allows members of your team to administrate the team and it's billing, without being charged for a Cursor license themselves.
Business plan teams always require at least one paid member. However, invoices for team changes are not billed immediately, so you can set up a team, invite a member and change your own role without being charged.
### How can I add Cursor to my company's MDM?
Use these permanent URLs that will always download the latest stable version of Cursor:
Download for all Macs
Download for all Macs
Download for Intel Macs
Download for Apple Silicon Macs
Download for 64-bit Windows
Download for ARM Windows
Download for 64-bit Windows
Download for ARM Windows
Download for 64-bit Windows
Download for ARM Windows
Download for 64-bit Linux
Download for ARM Linux
Then follow the instructions for your MDM:
formally VMware
Windows application management
macOS application management
Kandji custom app deployment
# SSO
Source: https://docs.cursor.com/account/teams/sso
Guide to setting up SAML 2.0 SSO authentication with your identity provider in Cursor for team accounts
## Overview
SAML 2.0 Single Sign-On (SSO) is available at no additional cost on the Cursor Business plan. This enables you to use your existing identity provider (IdP) to authenticate your team members, avoiding the need for your team members to have a Cursor account, and remember another password.
## Prerequisites
* A Cursor Business plan
* Admin access to your identity provider (e.g., Okta)
* Admin access to your Cursor organization
## Configuration Steps
Navigate to [cursor.com/settings](http://cursor.com/settings) and sign in with an admin account.
Find the "Configure SSO" button in the bottom left of the settings page
Click the button to start the SSO setup process, and follow the setup wizard to configure your identity provider.
In your identity provider (e.g., Okta):
* Create a new SAML application
* Configure the SAML settings using the information provided in Cursor
* Set up Just-in-Time (JIT) provisioning for seamless user access
### Identity Provider Setup Guides
For detailed setup instructions specific to your identity provider, refer to the guides below:
Access comprehensive setup instructions for all major identity providers including Okta, Azure AD, Google Workspace, and more.
SCIM provisioning coming H1 2025
## Additional Settings
* SSO enforcement is managed through the admin dashboard
* New users are automatically enrolled in your organization when they sign in through SSO
* User management can be handled directly through your identity provider
## Troubleshooting
If you encounter issues during setup:
* Verify your domain has been verified in Cursor
* Ensure all required SAML attributes are properly mapped
* Check that the SSO configuration is enabled in your admin dashboard
* If a user is unable to authenticate, ensure the first and last name set in the identity provider matches their name in Cursor
* Check the guides above for detailed setup instructions specific to your identity provider
* If you continue to experience issues, please reach out to us at [hi@cursor.com](mailto:hi@cursor.com)
# Notepads (Beta)
Source: https://docs.cursor.com/beta/notepads
A guide to using Notepads in Cursor for sharing context between Composers and Chat interactions
Notepads are currently in beta and subject to be deprecated in the future.
# Overview
Notepads are powerful context-sharing tools in Cursor that bridge the gap between composers and chat interactions. Think of them as enhanced reference documents that go beyond the capabilities of `.cursorrules`, allowing you to create reusable contexts for your development workflow.
Notepads serve as collections of thoughts, rules, and documentation that can be:
* Shared between different parts of your development environment
* Referenced using the `@` syntax
* Enhanced with file attachments
* Used as dynamic templates for various development scenarios
## Getting started
1. Click the "+" button in the Notepads section
2. Give your notepad a meaningful name
3. Add your content, context, files and other relevant information the same way you would in composer or chat.
4. Reference it in composers or chat using `@`
# Key features
* **Context Sharing**: Seamlessly share context between composers and chat
* **File Attachments**: Attach documentation and reference files (not possible in `.cursorrules`)
* **Dynamic References**: Use `@` mentions to link to other resources
* **Flexible Content**: Write and structure information in a way that suits your needs
# Common use cases
1. **Dynamic Boilerplate Generation**
* Create templates for common code patterns
* Store project-specific scaffolding rules
* Maintain consistent code structure across your team
2. **Architecture Documentation**
* Frontend specifications
* Backend design patterns
* Data model documentation
* System architecture guidelines
3. **Development Guidelines**
* Coding standards
* Project-specific rules
* Best practices
* Team conventions
## FAQ
### What should I write in Notepads?
Notepads are ideal for:
* Project architecture decisions
* Development guidelines and standards
* Reusable code templates
* Documentation that needs to be referenced frequently
* Team-specific conventions and rules
### What should not be written in Notepads?
Avoid using Notepads for:
* Temporary notes or scratch work
* Information that belongs in version control (like git)
* Sensitive data or credentials
* Highly volatile information that changes frequently
### Should I follow a particular format or structure?
While Notepads are flexible, we recommend:
* Using clear headings and sections
* Including examples where relevant
* Keeping content focused and organized
* Using markdown formatting for better readability
* Adding relevant file attachments when necessary
### Example Notepad
Here's a typical example of a Notepad for a web application project:
```md Notepad example
# API Development Guidelines
## Endpoint Structure
- Use RESTful conventions
- Base URL: `/api/v1`
- Resource naming in plural form
## Authentication
- JWT-based authentication
- Token format: Bearer {token}
- Refresh token mechanism required
## Response Format
{
"status": "success|error",
"data": {},
"message": "Optional message"
}
## Attached References
@api-specs.yaml
@auth-flow.md
```
# Agent Mode
Source: https://docs.cursor.com/chat/agent
Autonomous AI coding agent that independently explores, plans, and executes complex codebase changes with full tools
Agent is the default and most autonomous mode in Cursor, designed to handle complex coding tasks with minimal guidance. It has all [tools](/chat/tools) enabled to autonomously explore your codebase, read documentation, browse the web, edit files, and run terminal commands to complete tasks efficiently.
## Agent's Capabilities
Independently explores your codebase, identifies relevant files, and makes necessary changes
Uses all available tools to search, edit, create files, and run terminal commands
Builds a comprehensive understanding of your project structure and dependencies
Breaks complex tasks into manageable steps and executes them in sequence
Make sure to read [chat overview](/chat/overview) to learn more about how modes work in Cursor.
## Agent's Workflow
Much like a human, Agent mode follows a systematic approach to completing tasks:
Agent mode analyzes your request, and the context of the codebase to fully comprehend the task requirements and goals.
The agent may search through your codebase, documentation, and the web to identify relevant files and understand the current implementation.
Based on the analysis, the agent breaks down the task into smaller steps and plans the changes, learning from the available context as it goes.
The agent makes the necessary code modifications according to the plan across your entire codebase, also potentially suggesting new libraries, terminal commands to run or steps you should make outside of Cursor.
The agent will confirm the changes look correct after being made by [applying them](/chat/apply). If it notices any issues or linter errors (when supported by the language), it will attempt to fix them.
Once the agent is happy, it yields back and summarizes the changes it made.
Agent mode creates checkpoints before making changes, allowing you to revert if needed.
Learn more about [checkpoints](/chat/overview#checkpoints).
## Example Use Cases
For best results, be specific about what you want to accomplish, but you don't need to specify how the agent should approach the task.
```md
"Add a dark mode toggle to my React application"
```
Agent mode will:
1. Identify your application's styling approach
2. Add necessary theme state management
3. Create toggle component
4. Update styling across relevant components
5. Add persistence if appropriate
```md
"Optimize my API calls to implement caching and reduce redundant requests"
```
Agent mode will:
1. Find all API call locations
2. Implement appropriate caching strategy
3. Add cache invalidation logic
4. Update components to use cached data
## Configuration Options
* **Select a Model**: Pre-select a model for agent mode
* **Edit Keybindings**: Set keybindings for agent mode
* **Toggle Available Tools**: Toggle available tools
* **Enable Auto-run and Auto-fix Errors**: Enable auto-run and auto-fix errors (read more about [tool settings](/chat/tools#advanced-options))
When using Agent mode with auto-run enabled, review proposed changes carefully before confirming major modifications.
# Apply
Source: https://docs.cursor.com/chat/apply
Learn how to apply, accept, or reject code suggestions from chat using Cursor's Apply feature
Cursor's `Apply` allows you to quickly integrate a codeblock suggestion from the chat into your code.
## How Apply Works
Apply is a specialized model we've developed specifically for rapid code application. It's designed to efficiently handle large-scale code changes while maintaining precision and reliability.
The key advantage of Apply is its focused purpose - it doesn't need to understand or generate code itself. Instead, it works in tandem with your chosen Cursor model, which handles the intelligent code generation. Apply then takes those changes and efficiently applies them across thousands of lines of code in seconds, making it perfect for large-scale refactoring and updates.
## Apply Code Blocks
To apply a code block suggestion, you can press on the play button in the top right corner of each chat code block.
This will edit your file to incorporate the code produced by Chat. Since you can add the most context and have the most back-and-forth with the model in Chat,
we recommend Chat + Apply for more complex AI-driven code changes.
## Accept or Reject
Once you have applied a code block, you can go through the diffs and accept or reject the changes. You can also click
on the "Accept" or "Reject" buttons in the top right corner of the chat code block.
`Ctrl/⌘ Enter` to accept, `Ctrl/⌘ Backspace` to reject.
# Ask mode
Source: https://docs.cursor.com/chat/ask
Ask mode lets you explore and learn about codebases through AI search and queries without making changes
Ask is a "read-only" mode for the [Chat](/chat/overview) made to ask questions, explore, and learn about a codebase. It is a built-in mode in Cursor that has [search tools](/chat/tools#search) enabled by default.
Make sure to read [chat overview](/chat/overview) to learn more about how modes work in Cursor.
## Difference to Other Modes
Ask is unique to the other default modes (Agent and Manual) as it does not apply any suggested changes by default - this makes it a sort of "read only" mode, having the full ability to read files and other context, but without the ability to make any changes on its own.
This can be great for learning about a codebase you may not want to make changes to, or to plan out a solution with the AI before implementing it!
## Configuration Options
* **Model** - Pre-select a model that should be the default for Ask
* **Keybinding** - Set a keybinding to switch to the Ask mode
* **Search Codebase** - Allow Cursor to search for it's own context, instead of you having to manually @ files as context when you want the AI to see them
# Custom Modes
Source: https://docs.cursor.com/chat/custom-modes
Create custom Cursor modes with tailored tools and prompts to personalize AI assistance for specific workflows
Custom modes allows you to compose new modes with tools and prompts that fits your workflow. These are in addition to [Agent](/chat/agent.mdx), [Ask](/chat/ask.mdx), and [Manual](/chat/manual.mdx) mode which are built-in.
Custom modes are currently in beta.
You can enable custom modes from `Settings` → `Features` → `Chat` → `Custom modes`
## Creating a Custom Mode
To create a custom mode, you can open the mode menu and click `Add custom mode`. From there, you will have the option to select name, icon, shortcut as well as enabled tools and custom instructions.
We're considering adding a `.cursor/modes.json` file to your project to make it easier to create and share custom modes.
## Example Modes
While you can make a mode with any combination of tools and instructions, here are some examples of modes that you might find useful.
Encourages detailed explanations and frequent clarifying questions, without automatically applying edits or running tools.
**Tools:**
All `Search`
**Custom Instructions:**
Focus on explaining concepts thoroughly and ask clarifying questions before providing solutions
Focuses exclusively on enhancing existing code structure, without introducing new functionality or reading additional files.
**Tools:**
`Edit & Reapply`
**Custom Instructions:**
Focus solely on improving existing code structure without adding new functionality
Generates comprehensive implementation plans without directly modifying code, documenting the approach clearly in a `plan.md` file.
**Tools:**
`Codebase`, `Read file`, `Terminal`
**Custom Instructions:**
Create detailed implementation plans without making direct code changes. Write it to `plan.md`
Collects extensive information from various sources, including web searches and codebase exploration, before recommending solutions.
**Tools:**
`Codebase`, `Web`, `Read file`, `Search files`
**Custom Instructions:**
Gather comprehensive information from multiple sources before suggesting solutions
Aggressively applies all available tools, making bold changes proactively with minimal user confirmation.
**Tools:**
All tools with `Auto-apply edits` and `Auto-run` enabled
**Custom Instructions:**
Take initiative and make bold changes with minimal confirmation
Conducts an in-depth investigation by gathering extensive context from source files and terminal outputs, then proposes precise, targeted fixes.
**Tools:**
All `Search`, `Terminal`, `Edit & Reapply`
**Custom Instructions:**
Thoroughly investigate issues by gathering extensive context before proposing targeted fixes
## Custom Mode Setting
Cursor provides a powerful set of tools that you can use to customize your chat experience.
Learn about all the available tools that can be used in Chat.
## Resources
Alongside the above list, there are also a number of community resources available with ideas and suggestions for custom modes that have proven effective for other users.
Explore a curated collection of custom modes submitted by the community!
# Manual Mode
Source: https://docs.cursor.com/chat/manual
Make precise code changes with explicit file targeting - a focused editing mode with user-controlled tooling
Manual mode is designed for making targeted code modifications when you know exactly what changes are needed and where.
Unlike Agent mode, it does not explore the codebase or run terminal commands; it relies entirely on your specific instructions and the context you provide (e.g., via `@`-mentioning files).
## Manual's Capabilities
Applies specific code changes exactly as instructed by the user.
Follows user commands without autonomous exploration or planning.
Can make coordinated changes across multiple specified files.
Primarily uses file editing capabilities; lacks search and terminal tools.
Make sure to read [chat overview](/chat/overview) to learn more about how modes work in Cursor.
## Using Manual Mode
Manual mode allows for a more precise and targeted approach to code editing. It is designed for making targeted code modifications when you know exactly what changes are needed and where.
To make use of Manual mode, you need to explicitly mention the files you want to edit using the `@` symbol.
Create your request as you normally would in the chat.
Add context to your request by mentioning the files you want to edit using the `@` symbol.
After applying, you can review the changes. Manual mode may flag potential issues if linters are configured.
Once edits are applied, the task is considered complete.
Manual mode excels when you need control and precision, acting as an AI pair programmer executing your specific plan. Provide clear context and instructions for best results.
## Example Use Cases
Provide explicit file paths (using `@`) and clear descriptions of the changes you want.
**Refactoring Specific Functions**
"In @src/utils/helpers.ts and @src/components/UserProfile.tsx,rename the function `getUserData` to `fetchUserProfile` and update all call sites within these files."
Manual mode will:
1. Locate `getUserData` function definitions and calls *only within the specified files*.
2. Rename the function and update the call sites as instructed.
**Applying Boilerplate**
"Add the standard copyright header comment to the top of @src/newModule.js and @src/newService.java"
Manual mode will:
1. Open the specified files.
2. Insert the provided header comment at the beginning of each file.
## Configuration Options
* **Select a Model**: Pre-select a model specifically for Manual mode.
* **Edit Keybindings**: Set custom keybindings to quickly activate Manual mode.
* **Available Tools**: Manual mode primarily uses the file editing tool. Search and terminal tools are disabled.
# Overview
Source: https://docs.cursor.com/chat/overview
Natural language interface for exploring, editing, and managing code with contextual AI assistance in Chat mode
## What is Chat?
Chat (previously "Composer") is Cursor's AI assistant that lives in your sidebar, letting you interact with your codebase through natural language. You can ask questions, request code edits, get terminal command suggestions, and more - all without switching context.
### Core Capabilities
Ask questions about unfamiliar code, get explanations, or explore your codebase
Make small tweaks or large multi-file changes without manually navigating files
Get terminal command suggestions for your specific use case
Let Cursor search, reason and execute to automate your workflows
## Getting Started
Access Chat in the sidebar with `⌘+L` (Mac) or `Ctrl+L` (Windows/Linux). Type your request in natural language, and the AI will respond accordingly.
## What can I do with Chat?
Chat has the ability to learn your codebase and make changes to it on your behalf. This is a powerful way to implement new features, and is the perfect tool for feature requests.
Simply explain to the chat, using [Agent mode](/chat/agent), what feature you would like it to implement. Chat will look at your codebase, and any relevant files, and suggest any necessary changes across these fields.
In addition to code edits, Chat may suggest other changes, like adding new files, or adding packages with a package manager.
By leaning into its understanding of your codebase, and how each component fits together, Chat can help you refactor your codebase.
Explain to the chat the current structure of your codebase, and the changes you'd like to make. The agent can read the relevant code, plan its changes, and implement them to make refactors and project restructuring a breeze.
Chat is excellent at helping you get a new project off the ground!
Tell the chat what kind of project you are wanting to build, and explain any specific requirements you have for the desired technical stack, and the Agent will get to work for you, create the project structure, install the dependencies, and even write the initial code to get you started as quickly as possible.
## Modes
Chat offers different modes optimized for specific tasks:
Allow Cursor to **autonomously learn** your codebase, and make **codebase-wide changes** on your behalf
Get explanations and answers about your codebase, and plan out features with the AI
Make focused edits, using only the context you provide
Create custom modes to suit your specific workflows
Switch between modes using the mode picker or `⌘.` shortcut to match your current needs.
## Context
Chat understands your codebase by analyzing:
1. **Open files**: What you're currently viewing
2. **@-symbols**: Use [@-symbols](/context/@-symbols/overview) to reference specific code elements
3. **Project structure**: The organization of your files and dependencies
The interface suggests relevant context based on your query, ensuring accurate responses.
## Code Edits
When Chat suggests code changes:
1. **Review**: See the proposed changes in a diff view
2. **Apply**: In Ask mode, explicitly apply changes with the "Apply" button
3. **Accept/Reject**: After changes are made, decide whether to keep or discard them
Cursor's custom model applies suggested edits to files with thousands of lines in seconds.
Find out more about Cursor's custom-trained model for applying changes.
## Tabs
When using the Chat, you are able to run multiple conversations at once, and switch between them using Tabs.
To do this, simply hit `⌘+T` (Mac) or `Ctrl+T` (Windows/Linux) to create a new tab. Unlike chat history, tabs can be executed in parallel, and are not dependent on the previous request.
Cursor will intelligently track all simultaneous conversations, and allow you to switch between them at any time, while ensuring multiple tabs don't attempt to make changes to the same files at once.
## Checkpoints
Sometimes you may want to revert to a previous state of your codebase. Cursor helps you with this by automatically creating checkpoints of your codebase at each request you make, as well every time the AI makes changes to your codebase.
To revert to a previous state, you can either:
* Click the `Restore Checkpoint` button that appears within the input box of a previous request, as shown below
* Click the + button that shows at the left of a message in the chat history when hovered
## Rules
Cursor comes out the box with a carefully designed set of behaviors, but you can customize Cursor to fit your specific workflows, both in its interactions with you, and how it makes changes to your code.
Learn about Cursor's "rules" system for customizing AI behavior.
## Model Selection
By default, Cursor has an 'auto-select' option, which will intelligently select the best premium model for your request. This will always use 1 premium request as is, unless you have certain settings enabled that increase this, like long-context mode.
If you want more granular control over which model is used, you can manually select a model from the model picker.
Learn about Cursor's different AI models and how to switch between them.
When using custom modes, you can also select a fixed model for each mode, such as selecting `o1` for a `Planning` mode.
## History and Cost
Chat history has moved to the command palette. You can access it from the "Show history" button in Chat, as well as by running the "Show Chat History" command in the command palette. For models with usage-based pricing, view cost breakdowns by clicking the history icon.
## Code Review
Reviewing agent code is now simpler with a built-in diff view at the end of each conversation. You can access it by clicking the **Review changes** button at the end of a conversation.
## Managing Long Conversations
For extended conversations, Cursor summarizes earlier messages using smaller models to maintain speed and relevance without losing context.
When approaching the context window limit, Chat suggests starting a new conversation with reference to the current one.
## Questions
**What happened to the Composer?**
In past versions of Cursor, we had two seperate concepts: the chat, and the composer. The chat was a read-only interface, like the [Ask mode](/chat/ask), and the composer was what we now call [Manual mode](/chat/manual). With the addition of the Agent mode, and the idea that the AI was now capable at learning your codebase on its own, we decided to combine the chat and composer into a single interface, and call it Chat.
**Can I get notifications when Chat finishes processing?**
Yes, enable sound notifications from `Settings` → `Features` → `Chat` → `Play sound on finish` (Beta feature)
**How are long conversations handled?**
For long conversations, Cursor summarizes earlier messages with smaller models to maintain responsiveness while preserving key details.
**Can I access my conversation history on another computer?**
No, conversation history is stored locally and not tied to your Cursor account, so it's only available on the computer where it was created.
**How do I change the default Chat mode?**
Set your default mode from Settings → Features → Chat → Default chat mode to your preferred mode or the most recently used one.
# Tools
Source: https://docs.cursor.com/chat/tools
A guide to all available tools in Cursor's Chat modes for searching, editing, and interacting with your codebase
The following is a list of all the tools available to the modes within the [Chat](/chat/overview).
While these are fixes for Cursor's default modes, you can enable or disable any of these tools when building your own [custom modes](/chat/custom-modes).
Agents can perform up to 25 tool calls per session. If this limit is reached, you can press "Continue" to allow additional tool calls (each "Continue" counts as one [request](/account/plans-and-usage)).
## Search
These tools are used to search your codebase and the web to find relevant information.
Read the contents of a file within your codebase.
— Up to 750 lines in max mode
— Up to 250 lines in other modes
Read the structure of a directory without reading the contents of the files.
Perform semantic searches within your [indexed codebase](/context/codebase-indexing).
Search for exact keywords or patterns within files.
Quickly find files by name using fuzzy matching.
Generate search queries and perform web searches.
Retrieve specific [rules](/context/rules) based on rule type and description.
## Edit
These tools are used to make specific edits to your files and codebase.
Suggest edits to files and [applies](/chat/apply) them automatically.
Delete files autonomously (can be disabled in settings).
## Run
The Chat has the ability to interact with your terminal.
Cursor can execute terminal commands, and montitor the output.
By default, Cursor will use the first terminal profile available within Cursor that it can use.
To set your preferred terminal profile:
1. Open Command Palette (`Cmd/Ctrl+Shift+P`)
2. Search for "Terminal: Select Default Profile"
3. Choose your desired profile
## MCP Servers
Chat can make use of configured MCP servers to be able to interact with external services, such as databases or 3rd party APIs.
Toggle all available MCP servers. This will respect auto-run option.
Learn more about [MCP Servers](/context/model-context-protocol).
## Advanced Options
### `Auto-apply Edits`
Automatically apply edits without manual confirmation.
### `Auto-run`
Automatically execute terminal commands and accept edits. Useful for running test suites and verifying changes.
### Guardrails
Define guardrails and allow/deny lists for specific tools to control automatic execution. Configure these settings as needed.
### `Auto-fix Errors`
Automatically resolve linter errors and warnings.
# Overview
Source: https://docs.cursor.com/cmdk/overview
Learn how to use Cmd/Ctrl K in Cursor to generate, edit code and ask questions with the Prompt Bar
Cmd K, also known or "Ctrl K" on Windows/Linux, allows you to generate new code or edit existing code in the editor window.
## Prompt Bars
In Cursor, we call the bar that appears when you press `Ctrl/Cmd K` the "Prompt Bar". It works similarly to the AI input box for chat, in
which you can type normally, or use [@ symbols](context/@-symbols) to reference other context.
## Inline Generation
If no code is selected when you press `Ctrl/Cmd K`, Cursor will generate new code based on the prompt you type in the prompt bar.
## Inline Edits
For in-place edits, you can simply select the code you want to edit and type into the prompt bar.
## Follow-up Instructions
After each generation, you can further refine the prompt by adding more instructions to the prompt bar, and pressing `Enter` so the AI regenerates based on your follow-up instructions.
## Default Context
By default, Cursor will try to find different kinds of useful information to improve code generation, in addition to the manual [@ symbols](/context/@-symbols/@-files) you include.
Additional context may include related files, recently viewed files, and more. After gathering, Cursor ranks the context items by relevance to your edit/generation
and keeps the top items in context for the large language model.
## Quick Question
If you press `Option/Alt Enter` while in the prompt bar, Cursor will respond to any questions you have about the selection, and the context you have attached.
The contents of this conversation could be further used in follow-up generations, so you could simply type "do it" after Cursor comes up with a response to generate the code after a quick question.
# Terminal Cmd K
Source: https://docs.cursor.com/cmdk/terminal-cmdk
Use Cmd K in Cursor terminal to generate and run commands through a prompt bar interface
In the built-in Cursor terminal, you can press `Ctrl/⌘ K` to open a prompt bar on the bottom of the terminal.
This prompt bar allows you to describe your desired action in the terminal, and terminal Cmd K will generate a command.
You can accept the command by hitting `esc` or run the command immediately with `Ctrl/⌘ + Enter`.
By default, Terminal Cmd K sees your recent terminal history, your instructions, and anything else you put in the prompt bar as context.
# @Code
Source: https://docs.cursor.com/context/@-symbols/@-code
Learn how to reference code snippets in Cursor using @Code symbol and keyboard shortcuts for adding to Chat
To reference specific sections of code, you can use the `@Code` symbol.
## Code Preview
Similar to the [`@Files`](/context/@-symbols/@-files) symbol, Cursor will show a preview of the code's content so you can verify that the code you're referencing is the correct one.
## From the Editor
Another way to add code snippets as context is to select the code you want to reference, and click on either "Add to Chat" (`Ctrl/⌘ Shift L`) or "Add to Edit" (`Ctrl/⌘ Shift K`).
These will add the selected code snippet to either the Chat input box or the currently active Cmd K prompt bar.
To add a selected code to a new chat, you can press `Ctrl/⌘ L`.
# @Cursor Rules
Source: https://docs.cursor.com/context/@-symbols/@-cursor-rules
Reference and apply project-specific rules and guidelines using the @Cursor Rules symbol in chats and prompts
The `@Cursor Rules` symbol provides access to [project rules](/context/rules) and guidelines you've set up for your project, allowing you to explicitly apply them to your context.
# @Definitions
Source: https://docs.cursor.com/context/@-symbols/@-definitions
Add nearby code definitions to Cmd K context using the @Definitions symbol
This feature is currently only for Cmd K.
The `@Definitions` symbol adds all nearby definitions to Cmd K as context.
# @Docs
Source: https://docs.cursor.com/context/@-symbols/@-docs
Learn how to use, add, and manage custom documentation as context in Cursor using @Docs
Cursor comes with a set of third party docs crawled, indexed, and ready to be used as context. You can access them by using the `@Docs` symbol. You can find a list of our default pre-scraped docs [here](https://raw.githubusercontent.com/getcursor/crawler/main/docs.jsonl).
## Add Custom Docs
If you want to crawl and index custom docs that are not already provided, you can do so by `@Docs` > `Add new doc`.
The following modal will appear after you've pasted in the URL of your desired doc:
Cursor will then index and learn the doc, and you will be able to use it as context like any other doc. Make sure to add a trailing slash to the URL if you want to index all subpages and subdirectories
Cursor will automatically keep Docs indexed and will re-index them periodically to keep them up to date as they are edited or changed.
## Manage Custom Docs
Under `Cursor Settings` > `Features` > `Docs`, you will see the docs you have added.
You can edit, delete, or add new docs here.
# @Files
Source: https://docs.cursor.com/context/@-symbols/@-files
Learn how to reference files using @ in Cursor's Chat and Cmd K, with preview and chunking features
In AI input boxes such as in Chat and Cmd K, you can reference entire files by using `@Files`.
Also, if you continue to type after `@`, you will see your file search results after the [`@Code`](/context/@-symbols/@-code) strategy.
In order to make sure the file you're referencing is the correct file, Cursor will show a preview of the file's path. This is especially useful when you have multiple files with the same name in different folders.
### Chat Long File References
In Cursor's Chat, if the contents of a file is too long, Cursor will chunk the file into smaller chunks and rerank them based on relevance to the query.
{/*
commenting this out, not in product anymore afaik // ez 2025-02-09
### Cmd K Chunking Strategy
For Cmd K, Cursor uses the file references differently based on the content length as well.
- auto
- Automatically pick one of the three reading strategies based on the file size
- full file
- The entire file is used as context.
- outline
- Cursor parses the outline of the file and uses the information as context.
- chunks
- Cursor chunks the file into smaller chunks and picks the most relevant one.
*/}
### Drag and Drop
You can drag and drop files from the primary sidebar into Composer, Chat or Cmd K to add them as context.
# @Folders
Source: https://docs.cursor.com/context/@-symbols/@-folders
Reference folders as context in Chat & Composer for enhanced AI conversations
You can reference entire folders in Cursor as context. When using `@Folders` with Agent, it attaches a list of all items in the directory, which allows the Agent to search through the contents itself. This gives Agent the ability to explore and analyze the folder's contents independently as needed for the task at hand.
# @Git
Source: https://docs.cursor.com/context/@-symbols/@-git
Reference Git commits, diffs, and PRs as context in Cursor Chat to analyze changes and generate commit messages
Currently, `@Git` is only supported in Chat & Composer
In Cursor's Chat, you can use `@Git` to add git commits, diffs, or pull requests to your prompt.
## Common Use Cases
One common use case for `@Git` is to allow Cursor's AI to scan the diff and look for bugs or issues that could be caused by the diff.
You could also use `@Diff of Working State` to generate a commit message from your current diffs.
# @Link
Source: https://docs.cursor.com/context/@-symbols/@-link
Learn how to include and manage web links as context in Cursor's AI features by pasting URLs
## Paste Links
In order for Cursor to visit a link before paste the link and you'll see that the link is "tagged"
## Remove Links
By default, we automatically parse links and turn them into `@Links` in Chat.
If you prefer to have the link as plain text, click on the link and then click `Unlink`.
You can also paste without formatting (hold `Shift`) to make sure the link is not tagged
# @Lint Errors
Source: https://docs.cursor.com/context/@-symbols/@-lint-errors
Access and reference linting errors in your codebase
The `@Lint Errors` symbol automatically captures and provides context about any linting errors and warnings from your currently active file.
[Composer](/chat/agent) and [Agent](/chat/agent) can see lint errors by default
# @Notepads
Source: https://docs.cursor.com/context/@-symbols/@-notepads
Reference and include notepad contexts in Cursor conversations for reusable development workflows
The `@Notepads` symbol allows you to reference and include your [Notepads](/beta/notepads) as context in your conversations. Notepads are powerful context-sharing tools that bridge the gap between composers and chat interactions, allowing you to create reusable contexts for your development workflow.
# @Past Chats
Source: https://docs.cursor.com/context/@-symbols/@-past-chats
Include summarized chats from history
When working on complex tasks in [Chat](/chat), you might want to reference context or decisions from previous conversations. The `@Past Chats` symbol allows you to include summarized versions of your previous chats as context.
This is particularly useful when:
* You have a long Chat session with important context you want to reference
* You're starting a new but related task and want to maintain continuity
* You want to share the reasoning or decisions from a previous session
# @Recent Changes
Source: https://docs.cursor.com/context/@-symbols/@-recent-changes
Reference recently modified code as context for AI chat using the @Recent Changes symbol
Cursor automatically keeps track of recent changes made to your codebase. The `@Recent Changes` symbol allows you to pass these modifications as context
# @Web
Source: https://docs.cursor.com/context/@-symbols/@-web
Enables web search to dynamically add recent online information and documentation as context in Cursor commands
## `@Web`
With `@Web`, Cursor constructs a search query based on the query and the context you've provided, and searches the web to
find relevant information as additional context.
This can be useful to allow Cursor to find the most up-to-date information online, or to allow Cursor to scrape multiple websites in a few seconds to find the best answer, without the user having to manually search anywhere.
When using Agent mode, Cursor will automatically search the web when it needs up-to-date information or additional context.
# Overview
Source: https://docs.cursor.com/context/@-symbols/overview
Guide to using @ symbols in Cursor for referencing code, files, documentation and other context in chats
In Cursors input boxes, such as in Composer, Chat and Cmd K, you can use @ symbols by typing `@`. A popup menu will appear with a list of suggestions,
and it will automatically filter to only show the most relevant suggestions based on your input.
## Keyboard Shortcuts
You can navigate through the list of suggestions using the up/down arrow keys. You can hit `Enter` to select a suggestion. If the suggestion is a category, such as `Files`,
the suggestions will be filtered to only show the most relevant items within that category.
Here's the list of all @ symbols available:
* [@Files](/context/@-symbols/@-files) - Reference specific files in your project
* [@Folders](/context/@-symbols/@-folders) - Reference entire folders for broader context
* [@Code](/context/@-symbols/@-code) - Reference specific code snippets or symbols from your codebase
* [@Docs](/context/@-symbols/@-docs) - Access documentation and guides
* [@Git](/context/@-symbols/@-git) - Access git history and changes
* [@Notepads](/context/@-symbols/@-notepads) - Access notepads
* [@Past Chats](/context/@-symbols/@-past-chats) - Work with summarized composer sessions
* [@Cursor Rules](/context/@-symbols/@-cursor-rules) - Work with cursor rules
* [@Web](/context/@-symbols/@-web) - Reference external web resources and documentation
* [@Link (paste)](/context/@-symbols/@-link) - Create links to specific code or documentation
* [@Recent Changes](/context/@-symbols/@-recent-changes) - Create links to specific code or documentation
* [@Lint Errors](/context/@-symbols/@-lint-errors) - Reference lint errors ([Chat](/chat/overview) only)
* [@Definitions](/context/@-symbols/@-definitions) - Look up symbol definitions ([Cmd K](/cmdk/overview) only)
There are also some other symbols that can be used:
* [# Files](/context/@-symbols/pill-files) - Add files to the context without referencing
* [/ Commands](/context/@-symbols/slash-commands) - Add open and active files to the context
# #Files
Source: https://docs.cursor.com/context/@-symbols/pill-files
Select specific files using # prefix in Cursor's input fields, works alongside @ context controls for precision
Use `#` followed by a filename to focus on specific files. Combine this with `@` symbols for precise context control.
# /command
Source: https://docs.cursor.com/context/@-symbols/slash-commands
Use / commands to reference open editor tabs and add them as context for conversations with Cursor AI
You type `/`to quickly reference open editors and add them as context
* **Open editors**: All editors tabs currently open
* **Active editors**: All editor tabs in view. This is typically when splitting the layout to show multiple editors
# Codebase Indexing
Source: https://docs.cursor.com/context/codebase-indexing
Learn how to index your codebase in Cursor for more accurate AI assistance and search results
### Index your Codebase
For better and more accurate codebase answers, you can index your codebase. Behind the scenes, Cursor
computes embeddings for each file in your codebase, and will use these to improve the accuracy of your codebase answers.
When a project is opened, each Cursor instance will initialize indexing for that workspace. After the initial indexing setup is complete, Cursor will automatically index any new files added to your workspace to keep your codebase context current.
The status of your codebase indexing is under `Cursor Settings` > `Features` > `Codebase Indexing`.
### Advanced Settings
By default, Cursor will index all files in your codebase.
You can also expand the `Show Settings` section to access more advanced options.
Here, you can decide whether you want to enable automatic indexing for new repositories and configure the files
that Cursor will ignore during repository indexing.
Cursor uses the same package as VS Code to handle file ignoring, which means it respects all `.gitignore` files, including those in subdirectories. You can also create a `.cursorignore` file for user-specific ignore patterns, which you may want to add to your global `.gitignore` to avoid committing it to the repository.
If you have any large content files in your project that the AI definitely doesn't need to read, [ignoring those files](/context/ignore-files) could improve the accuracy of the answers.
### Working with large monorepos
When working with large monorepos containing hundreds of thousands of files, it's important to be strategic about what gets indexed.
* Use `.cursorignore` to let each developer configure which folders and paths they work on in the monorepo
* Add `.cursorignore` to your global `.gitignore`
This allows each developer to optimize indexing for their specific work areas within the monorepo.
## FAQ
### Where can I see all codebases I have indexed?
Currently, there is no way to see a list of all codebases you have indexed. You'll need to manually check each project's indexing status by opening the project in Cursor and checking the Codebase Indexing settings.
### How do I delete all codebases?
You can either delete your Cursor account from Settings to remove all indexed codebases, or manually delete individual codebases from the Codebase Indexing settings in each project. There's currently no way to delete all codebases at once without deleting your account.
# Ignore Files
Source: https://docs.cursor.com/context/ignore-files
Control which files Cursor's AI features and indexing can access using .cursorignore and .cursorindexingignore
## Overview
Cursor reads and indexes your project's codebase to power its features. You can control which directories and files Cursor can access by adding a `.cursorignore` file to your root directory.
Cursor makes its best effort to block access to files listed in `.cursorignore` from:
* Codebase indexing
* Code accessible by [Tab](/tab/overview), [Chat](/chat/overview), and [⌘K](/cmdk/overview)
* Code accessible via [@ symbol references](/context/@-symbols/overview)
Tool calls initiated by Cursor's Chat feature to services like Terminal and MCP servers are not currently able to block access to code governed by `.cursorignore`
## Global Ignore Files
You can now define ignore patterns that apply across all projects via your user-level settings. This keeps noisy or sensitive files like build outputs or secrets out of prompts, without needing per-project configuration.
## Why Ignore Files?
There are two common reasons to configure Cursor to ignore portions of your codebase:
### Security
While your codebase is not permanently stored on Cursor's servers or the LLMs that power its features, you may still want to restrict access to certain files for security reasons, such as files containing API keys, database credentials, and other secrets.
Cursor makes its best effort to block access to ignored files, but due to unpredictable LLM behavior, we cannot guarantee these files will never be exposed.
### Performance
If you work in a monorepo or very large codebase where significant portions are irrelevant to the code you're developing, you might consider configuring Cursor to ignore these parts of the application.
By excluding irrelevant parts of the codebase, Cursor will index large codebases faster and find files with more speed and accuracy when searching for context.
Cursor is designed to support large codebases and is skilled at assessing file relevancy, but the ignore feature is helpful when using a codebase that is especially large or includes files immaterial to your development.
## Configuring `.cursorignore`
To implement Cursor's ignore feature, add a `.cursorignore` file to the root of your codebase's directory and list the directories and files to be ignored.
The `.cursorignore` file uses pattern matching syntax identical to that used in `.gitignore` files.
### Basic Pattern Examples
```sh
# Ignore specific file `config.json`
config.json
# Ignore `dist` directory and all files inside
dist/
# Ignore all files with a `.log` extension
*.log
```
### Advanced Pattern Examples
```sh
# Ignore entire codebase
*
# Do not ignore `app` directory
!app/
# Ignores logs directories in any directory
**/logs
```
### Considerations
* Blank lines are ignored
* Lines starting with `#` are considered comments and ignored
* Patterns are matched relative to the location of the `.cursorignore` file
* Patterns will override conflicting patterns listed earlier in the file
## Limit Indexing with `.cursorindexingignore`
To implement Cursor's ignore feature for indexing only, add a `.cursorindexingignore` file to the root of your codebase's directory, and list the directories and files to be excluded from the index.
Files listed in `.cursorindexingignore` will not be included in Cursor's index but can still be accessed by Cursor's AI-assisted features, including when Cursor searches the codebase and exposes it to LLMs.
## Files Ignored by Default
Cursor will also ignore all files listed in the `.gitignore` file in your root directory and in the Default Ignore List provided below.
To not ignore a file listed in these files, add it to your `.cursorignore` file with an `!` prefix.
For indexing only, in addition to the files designated in your `.gitignore`, `.cursorignore` and `.cursorindexignore` files, the following files are also ignored:
```sh
package-lock.json
pnpm-lock.yaml
yarn.lock
composer.lock
Gemfile.lock
bun.lockb
.env*
.git/
.svn/
.hg/
*.lock
*.bak
*.tmp
*.bin
*.exe
*.dll
*.so
*.lockb
*.qwoff
*.isl
*.csv
*.pdf
*.doc
*.doc
*.xls
*.xlsx
*.ppt
*.pptx
*.odt
*.ods
*.odp
*.odg
*.odf
*.sxw
*.sxc
*.sxi
*.sxd
*.sdc
*.jpg
*.jpeg
*.png
*.gif
*.bmp
*.tif
*.mp3
*.wav
*.wma
*.ogg
*.flac
*.aac
*.mp4
*.mov
*.wmv
*.flv
*.avi
*.zip
*.tar
*.gz
*.7z
*.rar
*.tgz
*.dmg
*.iso
*.cue
*.mdf
*.mds
*.vcd
*.toast
*.img
*.apk
*.msi
*.cab
*.tar.gz
*.tar.xz
*.tar.bz2
*.tar.lzma
*.tar.Z
*.tar.sz
*.lzma
*.ttf
*.otf
*.pak
*.woff
*.woff2
*.eot
*.webp
*.vsix
*.rmeta
*.rlib
*.parquet
*.svg
.egg-info/
.venv/
node_modules/
__pycache__/
.next/
.nuxt/
.cache/
.sass-cache/
.gradle/
.DS_Store/
.ipynb_checkpoints/
.pytest_cache/
.mypy_cache/
.tox/
.git/
.hg/
.svn/
.bzr/
.lock-wscript/
.Python/
.jupyter/
.history/
.yarn/
.yarn-cache/
.eslintcache/
.parcel-cache/
.cache-loader/
.nyc_output/
.node_repl_history/
.pnp.js/
.pnp/
```
## Troubleshooting
To troubleshoot issues with your ignore files, try testing patterns using the `git check-ignore -v [file]` command.
# Model Context Protocol
Source: https://docs.cursor.com/context/model-context-protocol
Connect external tools and data sources to Cursor using the Model Context Protocol (MCP) plugin system
## What is MCP?
The [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction) is an open protocol that standardizes how applications provide context and tools to LLMs. Think of MCP as a plugin system for Cursor - it allows you to extend the Agent's capabilities by connecting it to various data sources and tools through standardized interfaces.
Visit the official MCP documentation to understand the protocol in depth
### Uses
MCP allows you to connect Cursor to external systems and data sources. This means you can integrate Cursor with your existing tools and infrastructure, instead of having to tell Cursor what the structure of your project is outside of the code itself.
MCP servers can be **written in any language** that can print to `stdout` or serve an HTTP endpoint. This flexibility allows you to implement MCP servers using your preferred programming language and technology stack very quickly.
#### Examples
Allow Cursor to query your databases directly, instead of manually feeding in schemas, or manipulating the data yourself.
Read data out of notion to guide cursor to implement a feature
Let Cursor create PRs, create branches, find code, etc
Allow Cursor to remember and recall information while you work
Allow Cursor to create customers, manage subscriptions, etc
### Architecture
MCP servers are lightweight programs that expose specific capabilities through the standardized protocol. They act as intermediaries between Cursor and external tools or data sources.
Cursor supports two transport types for MCP servers:
\- Runs on your **local machine**
\- Managed automatically by Cursor
\- Communicates directly via `stdout`
\- Only accessible by you locally
**Input:** Valid shell command that is ran by Cursor automatically
\- Can run **locally or remotely**
\- Managed and run by you
\- Communicates **over the network**
\- Can be **shared** across machines
**Input:** URL to the `/sse` endpoint of an MCP server external to Cursor
For stdio servers, the command should be a valid shell command that Cursor can run.
For SSE servers, the URL should be the URL of the SSE endpoint, e.g. `http://example.com:8000/sse`.
Each transport type has different use cases, with stdio being simpler for local development and SSE offering more flexibility for distributed teams.
## Configuring MCP Servers
The MCP configuration file uses a JSON format with the following structure:
```json CLI Server - Node.js
// This example demonstrated an MCP server using the stdio format
// Cursor automatically runs this process for you
// This uses a Node.js server, ran with `npx`
{
"mcpServers": {
"server-name": {
"command": "npx",
"args": ["-y", "mcp-server"],
"env": {
"API_KEY": "value"
}
}
}
}
```
```json CLI Server - Python
// This example demonstrated an MCP server using the stdio format
// Cursor automatically runs this process for you
// This uses a Python server, ran with `python`
{
"mcpServers": {
"server-name": {
"command": "python",
"args": ["mcp-server.py"],
"env": {
"API_KEY": "value"
}
}
}
}
```
```json SSE Server
// This example demonstrated an MCP server using the SSE format
// The user should manually setup and run the server
// This could be networked, to allow others to access it too
{
"mcpServers": {
"server-name": {
"url": "http://localhost:3000/sse",
"env": {
"API_KEY": "value"
}
}
}
}
```
The `env` field allows you to specify environment variables that will be available to your MCP server process. This is particularly useful for managing API keys and other sensitive configuration.
### Configuration Locations
You can place this configuration in two locations, depending on your use case:
For tools specific to a project, create a `.cursor/mcp.json` file in your project directory. This allows you to define MCP servers that are only available within that specific project.
For tools that you want to use across all projects, create a `\~/.cursor/mcp.json` file in your home directory. This makes MCP servers available in all your Cursor workspaces.
## Using MCP in Chat
The Composer Agent will **automatically** use any MCP tools that are listed under `Available Tools` on the MCP settings page if it determines them to be relevant.
To prompt tool usage intentionally, simply tell the agent to use the tool, referring to it either by name or by description.
### Tool Approval
By default, when Agent wants to use an MCP tool, it will display a message asking for your approval. You can use the arrow next to the tool name to expand the message, and see what arguments the Agent is calling the tool with.
#### Auto-run
You can enable auto-run to allow Agent to automatically run MCP tools without requiring approval, similar to how terminal commands are executed. Read more about Yolo mode and how to enable it [here](/chat/agent#yolo-mode).
### Tool Response
When a tool is used Cursor will display the response in the chat.
This image shows the response from the sample tool, as well as expanded views of the tool call arguments and the tool call response.
### Image Injection
When using some MCP servers, Cursor may run a tool that returns an image, such as a screenshot of a website, or a diagram. To allow the Chat to properly view and use the images in it's replies, you can ensure the server is configured to return the image in the correct format.
To do this, you can simply return a base64 encoded string of the image in the tool response.
```js
const RED_CIRCLE_BASE64 = "/9j/4AAQSkZJRgABAgEASABIAAD/2w..."
// ^ full base64 clipped for readability
server.tool("generate_image", async (params) => {
return {
content: [
{
type: "image",
data: RED_CIRCLE_BASE64,
mimeType: "image/jpeg",
},
],
};
});
```
A full example of an MCP server that returns an image can be found [here](https://github.com/msfeldstein/mcp-test-servers/blob/main/src/image-server.js).
By returning the image in this format, Cursor will attach the image into the chat, and if the current model supports it, the image will be viewed and analyzed by the model to help with the it's next steps.
## Limitations
MCP is a very new protocol and is still in active development. There are some known caveats to be aware of:
Some MCP servers, or user's with many MCP servers active, may have many tools available for Cursor to use. Currently, Cursor will only send the first 40 tools to the Agent.
Cursor directly communicates with MCP servers from your local machine, either directly through `stdio` or via the network using `sse`. Therefore, MCP servers may not work properly when accessing Cursor over SSH or other development environments. We are hoping to improve this in future releases.
MCP servers offer two main capabilities: tools and resources. Tools are available in Cursor today, and allow Cursor to execute the tools offered by an MCP server, and use the output in its further steps. However, resources are not yet supported in Cursor. We are hoping to add resource support in future releases.
# Rules
Source: https://docs.cursor.com/context/rules
Control how the Agent model behaves with reusable, scoped instructions.
Rules allow you to provide system-level guidance to the Agent and Cmd-K AI. Think of them as a persistent way to encode context, preferences, or workflows for your projects or for yourself.
We support three types of rules:
Stored in `.cursor/rules`, version-controlled and scoped to your codebase.
Global to your Cursor environment. Defined in settings and always applied.
Still supported, but deprecated. Use Project Rules instead.
***
## How rules work
Large language models do not retain memory between completions. Rules solve this by providing persistent, reusable context at the prompt level.
When a rule is applied, its contents are included at the start of the model context. This gives the AI consistent guidance whether it is generating code, interpreting edits, or helping with a workflow.
Rules apply to both [Chat](/chat/overview) and [Cmd K](/cmdk/overview)
***
## Project rules
Project rules live in `.cursor/rules`. Each rule is stored as a file and version-controlled. They can be scoped using path patterns, invoked manually, or included based on relevance.
Use project rules to:
* Encode domain-specific knowledge about your codebase
* Automate project-specific workflows or templates
* Standardize style or architecture decisions
### Rule structure
Each rule file is written in **MDC** (`.mdc`), a lightweight format that supports metadata and content in a single file. Rules supports the following types:
| Rule Type | Description |
| :--------------------------------------------- | :------------------------------------------------------------------------------------------- |
| `Always` | Always included in the model context |
| `Auto Attached` | Included when files matching a glob pattern are referenced |
| `Agent Requested` | Rule is available to the AI, which decides whether to include it. Must provide a description |
| `Manual` | Only included when explicitly mentioned using `@ruleName` |
#### Example MDC rule
```
---
description: RPC Service boilerplate
globs:
alwaysApply: false
---
- Use our internal RPC pattern when defining services
- Always use snake_case for service names.
@service-template.ts
```
Referenced files like `@service-template.ts` will be included as additional context when the rule is triggered.
You can use `Cmd + Shift + P` > "New Cursor Rule" to create a rule quickly from inside Cursor.
### Creating a rule
You can create a rule by using the `New Cursor Rule` command or going to `Cursor Settings > Rules`. This will create a new rule file in the `.cursor/rules` directory. From settings you can also see a list of all rules and their status.
### Generating rules
You can generate rules directly in a conversation using the `/Generate Cursor Rules` command.
This is very useful when you've had a conversation where many decisions were made about how the agent should behave. Simply generate the rule and reuse it in the future.
***
## Best practices
Good rules are focused, actionable, and scoped.
* Keep rules concise. Under 500 lines is a good target
* Split large concepts into multiple, composable rules
* Provide concrete examples or referenced files when helpful
* Avoid vague guidance. Write rules the way you would write a clear internal doc
* Reuse rules when you find yourself repeating prompts in chat
***
## Examples
This rule provides standards for frontend components, ensuring consistent styling and animations:
When working in the components directory:
* Always use Tailwind for styling
* Use Framer Motion for animations
* Follow our component naming conventions
This rule enforces validation standards for API endpoints:
In the API directory:
* Use zod for all validation
* Define return types with zod schemas
* Export types generated from schemas
This rule provides a template for creating new Express services:
Use this template when creating a new Express service:
* Follow RESTful principles
* Include error handling middleware
* Set up proper logging
@express-service-template.ts
This rule defines the structure for React components:
React components should follow this layout:
* Props interface at the top
* Component as named export
* Styles at the bottom
@component-template.tsx
This rule automates the app analysis workflow:
When I ask to analyze the app:
1. Run the dev server with `npm run dev`
2. Fetch logs from the console
3. Suggest performance improvements
This rule helps generate documentation from code:
Help me draft documentation by:
* Extracting code comments
* Analyzing README.md
* Generating markdown documentation
### From Cursor codebase
These are rules that we use internally at Cursor
Tailwind is supported in this VS Code fork!
Usage examples:
* `text-error-foreground`
* `bg-input-border`
First create a property to toggle in `@reactiveStorageTypes.ts`.
Add a default value for it in `INIT_APPLICATION_USER_PERSISTENT_STORAGE` in `@reactiveStorageService.tsx`.
If this is a beta feature, add a toggle in `@settingsBetaTab.tsx`, otherwise add it in `@settingsGeneralTab.tsx`. Toggles can be added as `` for general checkboxes. Look at the rest of the file for examples of other types.
```
{
vsContext.reactiveStorageService.setApplicationUserPersistentStorage(
'myNewProperty',
newVal
);
}}
/>
```
To use it in the app, import the reactiveStorageService and use the property
```
const flagIsEnabled = vsContext.reactiveStorageService.applicationUserPersistentStorage.myNewProperty
```
There are many examples available from providers like Next.js, Cloudflare, and Browserbase. Community-contributed rules can be found across multiple crowdsourced collections and repositories online.
***
## User rules
User rules are defined in **Cursor Settings > Rules**.
They apply to all projects and are always included in your model context.
Use them to:
* Set response language or tone
* Add personal style preferences
**Example:**
```
Please reply in a concise style. Avoid unnecessary repetition or filler language.
```
User rules do not support MDC, they are plain text only.
***
## Team rules
There is no built-in way to share rules across projects today.
We plan to support shared, MDC-formatted rules that can be referenced across team projects. Until then, you can:
* Store shared rules in a dedicated repository
* Copy or symlink them into each project's `.cursor/rules` directory
***
## `.cursorrules` (Legacy)
The `.cursorrules` file in the root of your project is still supported, but will be deprecated. We recommend migrating to the Project Rules format for more control, flexibility, and visibility.
***
## FAQ
**Why isn't my rule being applied?**\
Check the rule type. For `Agent Requested`, make sure a description is defined. For `Auto Attached`, ensure the file pattern matches the referenced files.
**Can rules reference other rules or files?**\
Yes. You can use `@filename.ts` to include files in your rule's context.
**Can I create a rule from chat?**\
Yes. Ask the AI to "turn this into a rule" or "make a reusable rule from this prompt".
**Do rules impact Cursor Tab or other AI features?**
No. Rules are only given to the Agent and Cmd-K AI models.
# FAQ
Source: https://docs.cursor.com/faq
Common questions about language support, models, project limits, and data management in Cursor with troubleshooting help
While Cursor works with any programming language, it excels with Python and JavaScript/TypeScript due to extensive model training data. It also performs well with Swift, C, and Rust. You can enhance support for any language by adding relevant documentation to your project.
Cursor leverages powerful foundational models like Claude 3.5 and GPT-4. For the most current library information, you can use our [@web](/context/@-symbols/@-web) search feature. Since core language concepts rarely change dramatically, the models maintain their effectiveness over time.
The MCP server serves as a bridge for bringing external context into Cursor. It enables connections to services like Google Drive and Notion, helping you incorporate documentation and requirements from these sources into your workflow.
Projects are limited to 10,000 files by default, though this can be adjusted if needed. To optimize indexing performance, you can use `.cursorignore` to exclude unnecessary files from the indexing process.
Currently, the simplest method is to place related repositories in the same directory and launch Cursor from there. We're actively developing improved support for managing multiple project folders.
Cursor is frequently updated with new features and improvements. You can find the latest changes and updates in our changelog at [cursor.com/changelog](https://cursor.com/changelog). We regularly release updates to enhance your experience and add new capabilities.
We roll out new releases gradually over multiple days to ensure stability. If you haven't received an update yet, you can expect it to show up soon. You can also manually check for updates by opening the Command Palette (Cmd/Ctrl + Shift + P) and typing "Attempt Update".
You can delete your account and all associated data by going to your [Dashboard](https://cursor.com/settings) and clicking the "Delete Account" button
**Additional resources**
* [Common Issues](/troubleshooting/common-issues) - Solutions to frequently encountered problems
* [Keyboard Shortcuts](/kbd) - Complete list of keybindings and shortcuts
# Installation
Source: https://docs.cursor.com/get-started/installation
Guide to installing Cursor, configuring initial settings, and migrating from other code editors
## Installation
1. Visit [cursor.com](https://cursor.com) and click the "Download" button
The installer for your operating system will automatically download
2. Run the installer and wait for installation to complete
3. Launch Cursor via the Desktop shortcut or from the Applications menu
## Setting up
On your first launch, you'll be prompted to configure a few settings to ensure you get up and running quickly!
If you are coming from a different editor, you can choose the default shortcuts you want to start with, so they are as familiar as possible.
If you want the AI to talk to you in a different language, you can enter the name of the language you want to use. This can be configured further in the [rules](/context/rules)
Cursor indexes your codebase locally to provide better AI suggestions. Learn more in [Codebase Indexing](/context/codebase-indexing).
You can choose to install `cursor` and `code` commands to launch Cursor from the terminal.
After configuring these settings, you will have the option to import your VS Code settings in one click. If you accept, this will import your extensions, themes, user settings, and keyboard shortcuts into Cursor, so you can get started right away.
Next, you'll be asked about your data preference. To learn more about this, and make an informed decision, read more about our dedicated [privacy page](/account/privacy)
## Logging In
1. Once you click **"Sign Up"** or **"Login"**, you'll be prompted to setup an account.
You can choose to use your email, or sign up with Google or GitHub.
2. Once signed in, you'll be sent back to Cursor and you'll be **ready to start coding!**
If you're using Cursor for the first time, you'll get a 14-day free trial of
Cursor Pro as soon as you sign up. Learn more about Cursor Pro on our
[website](https://cursor.com/features).
## Migrating from other editors
While Cursor is built on top the same core as VS Code, there are some key differences that you should be aware of. Additionally, for those coming from other editors, you may not be familiar with the structure of Cursor.
To help you get started, we've put together a guide to help you migrate from other editors.
We hope to add more migration guides for other editors soon!
## Next Steps
Now that you've installed Cursor, head over to the [Introduction](/get-started/introduction) to learn about Cursor's features and how to get started using them.
# Introduction
Source: https://docs.cursor.com/get-started/introduction
Learn about Cursor's core AI features, settings, and customization options for powerful code development.
## Overview
Cursor is a powerful AI-first code editor that enhances your development workflow. After [installation](/get-started/installation), you'll have access to these core features that work together seamlessly to make you more productive:
* **AI-powered code completion** that understands your codebase and provides context-aware suggestions
* **Conversation interface** for exploring, understanding, and modifying code with Ask, Edit, and Agent modes
* **Intelligent tools** for handling complex development tasks
## Getting Started
Start exploring Cursor's AI-powered features:
* **Tab**: Press `Tab` for intelligent code completions
* **CMD-K**: Use `Cmd/Ctrl + K` for inline code edits
* **Chat**: Use `⌘I` to open the unified AI interface with Ask, Edit, and Agent modes
## Settings
Cursor is designed to be flexible and customizable. You can configure it in two ways:
### Cursor Settings
* Access via gear icon, `Cmd/Ctrl + Shift + J`, or Command Palette > `Cursor Settings`
* Configure AI features and Cursor-specific preferences
### Editor Settings
* Access via Command Palette (`Cmd/Ctrl + Shift + P`) > `"Preferences: Open Settings (UI)"`
* Adjust editor behavior and appearance
Let's explore each feature in detail:
### Tab
Tab completion in Cursor is powered by advanced AI models that understand your code context. As you type, you'll receive intelligent suggestions that:
* Complete your current line of code
* Suggest entire function implementations
* Help with common patterns and boilerplate
* Adapt to your coding style over time
Learn more about [Tab features](/tab/overview) or see how it [compares to GitHub Copilot](/tab/from-gh-copilot).
### Chat
Cursor provides a unified AI interface with three modes that seamlessly work together:
**Agent Mode (Default)**
* Make codebase-wide changes and refactoring
* Implement new features from requirements
* Debug complex issues across multiple files
* Generate tests and documentation
* Maintain consistency across your entire project
**Ask Mode**
* Ask questions about specific code sections
* Get explanations of complex functions
* Find code patterns and examples
* Discover and understand your codebase
**Custom modes**
* Create your own modes that fits your workflow
Switch between modes during conversations to best suit your current task. Learn more about the [unified AI interface](/chat/overview) or explore specific capabilities in [Agent mode](/chat/overview).
### Context
Context is the foundation that powers all of Cursor's AI features. Here's how it works:
* When you open a codebase, we automatically [index your code](/context/codebase-indexing) to make it available as context
* Use [@-symbols](/context/@-symbols/overview) to precisely control what context you provide:
* [@files](/context/@-symbols/@-files) and [@folders](/context/@-symbols/@-folders) for specific paths
* [@web](/context/@-symbols/@-web) for external documentation
* [@git](/context/@-symbols/@-git) for version control context
* Configure [rules](/context/rules) to customize behavior
* Set up [MCP](/context/model-context-protocol) for external context providers
## Models
You can see all the models we support and their pricing on the [models page](/settings/models). Configure your [API keys](/settings/api-keys) and [preferences](/settings/preferences) in Settings.
## Usage
It's highly recommended to read about [usage](/account/plans-and-usage) and [plans](/account/plans-and-usage) to understand how Cursor pricing works. Check out our [pricing page](/account/pricing) for more details about plans and features.
Need help? Visit our [troubleshooting guide](/troubleshooting/troubleshooting-guide) or join our [community forum](https://discord.com/invite/cursor).
# Welcome to Cursor
Source: https://docs.cursor.com/get-started/welcome
Get started with Cursor IDE & learn core features: Tab completion, Chat AI pair programming, and Cmd-K editing
Cursor is a new, intelligent IDE, empowered by seamless integrations with AI.
Built upon VSCode, Cursor is quick to learn, but can make you extraordinarily productive.
## Get Started
If you're new to Cursor, you can get started using the guides below.
Learn about Cursor's core features and concepts.
Get started with Cursor in minutes, by downloading and installing for your
platform.
## The Editor
Cursor has a number of core features that will seamlessly integrate with your workflow.
Use the links below to learn more about what Cursor can do.
Smart code completion that learns from you! Make multi-line edits, fix
errors you might have missed, and predict your next action.
Your AI pair programmer for complex code changes. Make large-scale edits
with context control and automatic fixes.
Quick inline code editing and generation. Perfect for making precise
changes without breaking your flow.
## Where did Cursor come from?
Code is fundamentally text, and our tools for writing it have evolved from simple text editors into increasingly intelligent development environments.
Initially, we had features like syntax highlighting, to make code more readable. Then, we had features like autocomplete, to make code more efficient.
These have been the standard for a long time, but with Cursor, we're re-inventing how you work with code.
## How does it work?
Cursor provides the user with a few fundamental features that are only made possible by the development of LLMs (Large Language Models).
## How do I get started?
You can download Cursor from the [Cursor website](https://www.cursor.com) for your platform of choice. Being based on VS Code, it's extremely easy to get started, and all the AI features are opt-in.
You can also have Cursor import all your VS Code extensions and settings in one-click. To help you try Cursor, we have a 14-day free trial our of Pro plan, with no credit card required!
## Community and Resources
To help you make the most of Cursor, we have a community of users and resources that you can use to get help and share your own experiences.
For **technical queries**, and to share your own experiences, please visit our dedicated forum, to talk to **members of the team** and **other Cursor users**.
For other queries, including accounts, billing, and sales, please email our support team. **Due to high demand, response times may be slower than the forum.**
# Java
Source: https://docs.cursor.com/guides/languages/java
Complete guide to setting up Java development in Cursor: JDK setup, extensions, debugging, and Maven/Gradle integration
This guide will help you configure Cursor for Java development, including setting up the JDK, installing necessary extensions, debugging, running Java applications, and integrating build tools like Maven and Gradle. It also covers workflow features similar to IntelliJ or VS Code.
Before starting, ensure you have Cursor installed and updated to the latest version.
## Setting up Java for Cursor
### Java Installation
Before setting up Cursor itself, you will need Java installed on your machine.
Cursor does not ship with a Java compiler, so you need to install a JDK if you haven't already.
Download and install a JDK (e.g., OpenJDK, Oracle JDK, Microsoft Build of OpenJDK).
Set JAVA\_HOME and add JAVA\_HOME\bin to your PATH.
Install via Homebrew (`brew install openjdk`) or download an installer.
Ensure JAVA\_HOME points to the installed JDK.
Use your package manager (`sudo apt install openjdk-17-jdk` or equivalent) or install via SDKMAN.
To check installation, run:
```bash
java -version
javac -version
```
If Cursor does not detect your JDK, configure it manually in settings.json:
```json
{
"java.jdt.ls.java.home": "/path/to/jdk",
"java.configuration.runtimes": [
{
"name": "JavaSE-17",
"path": "/path/to/jdk-17",
"default": true
}
]
}
```
Restart Cursor to apply changes.
### Cursor Setup
Cursor supports VS Code extensions. Install the following manually:
Includes Java language support, debugger, test runner, Maven support, and project manager
Essential for working with Gradle build system
Required for Spring Boot development
Necessary for JavaFX application development
### Configure Build Tools
#### Maven
Ensure Maven is installed (`mvn -version`). Install from [maven.apache.org](https://maven.apache.org/download.cgi) if needed:
1. Download the binary archive
2. Extract to desired location
3. Set MAVEN\_HOME environment variable to the extracted folder
4. Add %MAVEN\_HOME%\bin (Windows) or \$MAVEN\_HOME/bin (Unix) to PATH
#### Gradle
Ensure Gradle is installed (`gradle -version`). Install from [gradle.org](https://gradle.org/install/) if needed:
1. Download the binary distribution
2. Extract to desired location
3. Set GRADLE\_HOME environment variable to the extracted folder
4. Add %GRADLE\_HOME%\bin (Windows) or \$GRADLE\_HOME/bin (Unix) to PATH
Alternatively, use the Gradle Wrapper which will automatically download and use the correct Gradle version:
## Running and Debugging
Now you are all set up, it's time to run and debug your Java code.
Depending on your needs, you can use the following methods:
Click the "Run" link that appears above any main method to quickly execute your program
Open the Run and Debug sidebar panel and use the Run button to start your application
Execute from command line using Maven or Gradlecommands
Launch Spring Boot applications directly from the Spring Boot Dashboard extension
## Java x Cursor Workflow
Cursor's AI-powered features can significantly enhance your Java development workflow. Here are some ways to leverage Cursor's capabilities specifically for Java:
Smart completions for methods, signatures, and Java boilerplate like getters/setters.
Implement design patterns, refactor code, or generate classes with proper inheritance.
Quick inline edits to methods, fix errors, or generate unit tests without breaking flow.
Get help with Java concepts, debug exceptions, or understand framework features.
### Example Workflows
1. **Generate Java Boilerplate**\
Use [Tab completion](/tab/overview) to quickly generate constructors, getters/setters, equals/hashCode methods, and other repetitive Java patterns.
2. **Debug Complex Java Exceptions**\
When facing a cryptic Java stack trace, highlight it and use [Ask](/chat/overview) to explain the root cause and suggest potential fixes.
3. **Refactor Legacy Java Code**\
Use [Agent mode](/chat/agent) to modernize older Java code - convert anonymous classes to lambdas, upgrade to newer Java language features, or implement design patterns.
4. **Frameworks Development**\
Add your documentation to Cursor's context with @docs, and generate framework-specific code throughout Cursor.
# JavaScript & TypeScript
Source: https://docs.cursor.com/guides/languages/javascript
Complete guide to JavaScript & TypeScript development in Cursor, featuring extensions, AI tools, and framework support
Welcome to JavaScript and TypeScript development in Cursor! The editor provides exceptional support for JS/TS development through its extension ecosystem. Here's what you need to know to get the most out of Cursor.
## Essential Extensions
While Cursor works great with any extensions you prefer, we recommend these for those just getting started:
* **ESLint** - Required for Cursor's AI-powered lint fixing capabilities
* **JavaScript and TypeScript Language Features** - Enhanced language support and IntelliSense
* **Path Intellisense** - Intelligent path completion for file paths
## Cursor Features
Cursor enhances your existing JavaScript/TypeScript workflow with:
* **Tab Completions**: Context-aware code completions that understand your project structure
* **Automatic Imports**: Tab can automatically import libraries as soon as you use them
* **Inline Editing**: Use `CMD+K` on any line to edit with perfect syntax
* **Composer Guidance**: Plan and edit your code across multiple files with the Composer
### Framework Intelligence with @Docs
Cursor's @Docs feature lets you supercharge your JavaScript development by adding custom documentation sources that the AI can reference. Add documentation from MDN, Node.js, or your favorite framework to get more accurate and contextual code suggestions.
Discover how to add and manage custom documentation sources in Cursor.
### Automatic Linting Resolution
One of Cursor's standout features is its seamless integration with Linter extensions.
Ensure you have a linter, like ESLint, setup, and enable the 'Iterate on Lints' setting.
Then, when using the Agent mode in Composer, once the AI has attempted to answer your query, and has made any code changes, it will automatically read the output of the linter and will attempt to fix any lint errors it might not have known about.
## Framework Support
Cursor works seamlessly with all major JavaScript frameworks and libraries, such as:
### React & Next.js
* Full JSX/TSX support with intelligent component suggestions
* Server component and API route intelligence for Next.js
* Recommended: [**React Developer Tools**](https://marketplace.visualstudio.com/items?itemName=msjsdiag.vscode-react-native) extension
### Vue.js
* Template syntax support with Volar integration
* Component auto-completion and type checking
* Recommended: [**Vue Language Features**](https://marketplace.visualstudio.com/items?itemName=Vue.volar)
### Angular
* Template validation and TypeScript decorator support
* Component and service generation
* Recommended: [**Angular Language Service**](https://marketplace.visualstudio.com/items?itemName=Angular.ng-template)
### Svelte
* Component syntax highlighting and intelligent completions
* Reactive statement and store suggestions
* Recommended: [**Svelte for VS Code**](https://marketplace.visualstudio.com/items?itemName=svelte.svelte-vscode)
### Backend Frameworks (Express/NestJS)
* Route and middleware intelligence
* TypeScript decorator support for NestJS
* API testing tools integration
Remember, Cursor's AI features work well with all these frameworks, understanding their patterns and best practices to provide relevant suggestions. The AI can help with everything from component creation to complex refactoring tasks, while respecting your project's existing patterns.
# Python
Source: https://docs.cursor.com/guides/languages/python
Comprehensive guide to setting up Python development in Cursor with essential extensions, linting and tools
This guide was heavily inspired by [Jack Fields](https://x.com/OrdinaryInds) and his [article](https://medium.com/ordinaryindustries/the-ultimate-vs-code-setup-for-python-538026b34d94) about setting up VS Code for Python development. Please check his article for more details.
## Prerequisites
Before we begin, ensure you have:
* [Python](https://python.org) installed (3.8 or higher recommended)
* [Git](https://git-scm.com/) for version control
* Cursor installed and updated to the latest version
## Essential Extensions
### Core Python Support
The following extensions setup Cursor to be fully featured for Python development. These provide you with syntax highlighting, linting, debugging and unit testing.
Core language support from Microsoft
Fast Python language server
Enhanced debugging capabilities
Visual testing interface
### Code Quality Tools
Automatic documentation generation
Manage Python paths
Virtual environment management
Code snippets for Python
### Advanced Python Tooling
While the above extensions have previously been the most popular extensions for Python development in Cursor, we've also added some additional extensions that can help you get the most out of your Python development.
#### `uv` - Python Environment Manager
[uv](https://github.com/astral-sh/uv) is a modern Python package manager that can be used to create and manage virtual environments, in addition to replacing pip as the default package manager.
To install uv, run the following command in your terminal:
```bash
pip install uv
```
#### `ruff` - Python Linter and Formatter
[Ruff](https://docs.astral.sh/ruff/) is a modern Python linter and formatter that can be used to check for programming errors, helps enforce coding standards, and can suggest refactoring. It can be used alongside Black for code formatting.
To install Ruff, run the following command in your terminal:
```bash
pip install ruff
```
## Cursor Configuration
### 1. Python Interpreter
Configure your Python interpreter in Cursor:
1. Open Command Palette (Cmd/Ctrl + Shift + P)
2. Search for "Python: Select Interpreter"
3. Choose your Python interpreter (or virtual environment if you're using one)
### 2. Code Formatting
Set up automatic code formatting with Black:
Black is a code formatter that automatically formats your code to follow a consistent style. It requires zero configuration and is widely adopted in the Python community.
To install Black, run the following command in your terminal:
```bash
pip install black
```
Then, configure Cursor to use Black for code formatting, by adding the following to your `settings.json` file:
```json
{
"python.formatting.provider": "black",
"editor.formatOnSave": true,
"python.formatting.blackArgs": [
"--line-length",
"88"
]
}
```
### 3. Linting
We can use PyLint to check for programming errors, helps enforce coding standards, and can suggest refactoring.
To install PyLint, run the following command in your terminal:
```bash
pip install pylint
```
```json
{
"python.linting.enabled": true,
"python.linting.pylintEnabled": true,
"python.linting.lintOnSave": true
}
```
### 4. Type Checking
In addition to linting, we can use MyPy to check for type errors.
To install MyPy, run the following command in your terminal:
```bash
pip install mypy
```
```json
{
"python.linting.mypyEnabled": true
}
```
## Debugging
Cursor provides powerful debugging capabilities for Python:
1. Set breakpoints by clicking the gutter
2. Use the Debug panel (Cmd/Ctrl + Shift + D)
3. Configure `launch.json` for custom debug configurations
## Recommended Features
Intelligent code suggestions that understand your actions
Explore and understand code through natural conversations
Handle complex development tasks with AI assistance
Pull in context from 3rd party systems
Automatically import modules as you code
Cursor constantly reviews your code with AI
## Framework Support
Cursor works seamlessly with popular Python frameworks:
* **Web Frameworks**: Django, Flask, FastAPI
* **Data Science**: Jupyter, NumPy, Pandas
* **Machine Learning**: TensorFlow, PyTorch, scikit-learn
* **Testing**: pytest, unittest
* **API**: requests, aiohttp
* **Database**: SQLAlchemy, psycopg2
# iOS & macOS (Swift)
Source: https://docs.cursor.com/guides/languages/swift
Guide to integrating Cursor with Swift development workflows using Xcode, hot reloading, and Sweetpad tools
Welcome to Swift development in Cursor! Whether you're building iOS apps, macOS applications, or server-side Swift projects, we've got you covered. This guide will help you set up your Swift environment in Cursor, starting with the basics and moving on to more advanced features.
## Basic Workflow
The simplest way to use Cursor with Swift is to treat it as your primary code editor while still relying on Xcode for building and running your apps. You'll get great features like:
* Smart code completion
* AI-powered coding assistance (try [CMD+K](/cmdk/overview) on any line)
* Quick access to documentation with [@Docs](/context/@-symbols/@-docs)
* Syntax highlighting
* Basic code navigation
When you need to build or run your app, simply switch to Xcode. This workflow is perfect for developers who want to leverage Cursor's AI capabilities while sticking to familiar Xcode tools for debugging and deployment.
### Hot Reloading
When using Xcode workspaces or projects (instead of opening a folder directly in Xcode), Xcode can often ignore changes to your files that were made in Cursor, or outside of Xcode in general.
While you can open the folder in Xcode to resolve this, you may need to use a project for your Swift development workflow.
A great solution to this is to use [Inject](https://github.com/krzysztofzablocki/Inject), a hot reloading library for Swift that allows your app to "hot reload" and update as soon as changes are made in real time. This does not suffer from the side effects of the Xcode workspace/project issue, and allows you to make changes in Cursor and have them reflected in your app immediately.
Learn more about Inject and how to use it in your Swift projects.
## Advanced Swift Development
This section of the guide was heavily inspired by [Thomas Ricouard](https://x.com/Dimillian) and his [article](https://dimillian.medium.com/how-to-use-cursor-for-ios-development-54b912c23941) about using Cursor for iOS development. Please check his article for more details and drop him a follow for more Swift content.
If you are looking to only need one editor open at a time, and want to avoid the need to switch between Xcode and Cursor, you can use an extension like [Sweetpad](https://sweetpad.hyzyla.dev/) to integrate Cursor directly with Xcode's underlying build system.
Sweetpad is a powerful extension that allows you to build, run and debug your Swift projects directly in Cursor, without compromising on Xcode's features.
To get started with Sweetpad, you'll still need to have Xcode installed on your Mac - it's the foundation of Swift development. You can download Xcode from the [Mac App Store](https://apps.apple.com/us/app/xcode/id497799835). Once you have Xcode set up, let's enhance your development experience in Cursor with a few essential tools.
Open your terminal and run:
```bash
# Builds your projects without needing Xcode open
brew install xcode-build-server
# Pretty print's the `xcodebuild` command output into Cursor's terminal
brew install xcbeautify
# Allows for advanced formating and language features
brew install swiftformat
```
Next, install the [Swift Language Support](https://marketplace.visualstudio.com/items?itemName=sswg.swift-lang) extension in Cursor. This will give you syntax highlighting and basic language features right out of the box.
Then, we can install the [Sweetpad](https://sweetpad.hyzyla.dev/) extension to integrate Cursor with Xcode. Sweetpad wraps a bunch of shortcuts around the `xcodebuild` CLI (and much more), and allows you to scan your targets, select the destination, build, and run your app just like Xcode. On top of that, it’ll set up your project for Xcode Build Server so you get all the features mentioned above.
### Sweetpad Usage
Once Sweetpad is installed, and you have a Swift project open in Cursor, you should first run the `Sweetpad: Generate Build Server Config` command. This will generate a `buildServer.json` file in the root of your project that allows the Xcode Build Server to work with your project.
Then, from either the Command Palette or the Sweetpad sidebar, you can select the target you want to build and run.
You need to build your project once to enable auto-completion, jump to definition, and other language features.
You can also now hit F5 to build and run your project with a debugger - you might need to create a launch configuration first, but just select Sweetpad from the list when prompted!
As with many extensions in Cursor, you can bind many of the Sweetpad commands to keyboard shortcuts, to make your workflow even more efficient.
To learn more about Sweetpad, check out these resources:
Official Sweetpad website with features and installation instructions
Comprehensive guide covering configuration, usage and advanced features
# Migrate from JetBrains IDEs
Source: https://docs.cursor.com/guides/migration/jetbrains
Guide to migrating from JetBrains IDEs to Cursor: setup extensions, themes, shortcuts, and language-specific tools
Cursor offers a modern, AI-powered coding experience that can replace your JetBrains IDEs. While the transition might feel different at first, Cursor's VS Code-based foundation provides powerful features and extensive customization options.
## Editor Components
### Extensions
JetBrains IDEs are great tools, as they come already pre-configured for the languages and frameworks they are intended for.
Cursor is different - being a blank canvas out of the box, you can customize it to your liking, not being limited by the languages and frameworks the IDE was intended for.
Cursor has access to a vast ecosystem of extensions, and almost all of the functionality (and more!) that JetBrains IDEs offer can be recreated through these extensions.
Take a look at some of these popular extensions below:
SSH, WSL, and Containers
Manage multiple projects
Enhanced Git integration
Track local file changes
Inline error highlighting
Code linting
Code formatting
Track TODOs and FIXMEs
### Keyboard Shortcuts
Cursor has a built-in keyboard shortcut manager that allows you to map your favorite keyboard shortcuts to actions.
With this extension, you can bring almost all of the JetBrains IDEs shortcuts directly to Cursor!
Be sure to read the extension's documentation to learn how to configure it to your liking:
Install this extension to bring JetBrains IDEs keyboard shortcuts to Cursor.
Common shortcuts that differ:
* Find Action: ⌘/Ctrl+Shift+P (vs. ⌘/Ctrl+Shift+A)
* Quick Fix: ⌘/Ctrl+. (vs. Alt+Enter)
* Go to File: ⌘/Ctrl+P (vs. ⌘/Ctrl+Shift+N)
### Themes
Recreate the look and feel of your favorite JetBrains IDEs in Cursor with these community themes.
Choose from the standard Darcula Theme, or pick a theme to match the syntax highlighting of your JetBrains tools.
Experience the classic JetBrains Darcula dark theme
Get the familiar JetBrains file and folder icons
### Font
To complete your JetBrains-like experience, you can use the official JetBrains Mono font:
1. Download and install JetBrains Mono font onto your system:
2. Restart Cursor after installing the font
3. Open Settings in Cursor (⌘/Ctrl + ,)
4. Search for "Font Family"
5. Set the font family to `'JetBrains Mono'`
For the best experience, you can also enable font ligatures by setting `"editor.fontLigatures": true` in your settings.
## IDE-Specific Migration
Many users loved the JetBrains IDEs for their out-the-box support for the languages and frameworks they were intended for. Cursor is different - being a blank canvas out of the box, you can customize it to your liking, not being limited by the languages and frameworks the IDE was intended for.
Cursor already has access to the extension ecosystem of VS Code, and almost all of the functionality (and more!) that JetBrains IDEs offer can be recreated through these extensions.
Take a look at the following suggested extensions for each JetBrains IDE below.
### IntelliJ IDEA (Java)
Core Java language features
Java debugging support
Run and debug Java tests
Maven support
Project management tools
Key differences:
* Build/Run configurations are managed through launch.json
* Spring Boot tools available through ["Spring Boot Tools"](https://marketplace.visualstudio.com/items?itemName=Pivotal.vscode-spring-boot) extension
* Gradle support via ["Gradle for Java"](https://marketplace.visualstudio.com/items?itemName=vscjava.vscode-gradle) extension
### PyCharm (Python)
Core Python support
Fast type checking
Notebook support
Test management
Key differences:
* Virtual environments managed through command palette
* Debug configurations in launch.json
* Requirements management through requirements.txt or Poetry
### WebStorm (JavaScript/TypeScript)
Latest language features
React development
Vue.js support
Angular development
Most WebStorm features are built into Cursor/VS Code, including:
* npm scripts view
* Debugging
* Git integration
* TypeScript support
### PhpStorm (PHP)
PHP language server
Xdebug integration
Code intelligence
Documentation tools
Key differences:
* Xdebug configuration through launch.json
* Composer integration via terminal
* Database tools through ["SQLTools"](https://marketplace.visualstudio.com/items?itemName=mtxr.sqltools) extension
### Rider (.NET)
Core C# support
Enhanced .NET tools
Unity development
.NET SDK management
Key differences:
* Solution explorer through file explorer
* NuGet package management through CLI or extensions
* Test runner integration through test explorer
### GoLand (Go)
Official Go extension
Test management
Documentation tools
Key differences:
* Go tools installation prompted automatically
* Debugging through launch.json
* Package management integrated with go.mod
## Tips for a Smooth Transition
Press ⌘/Ctrl + Shift + P to find commands
Leverage Cursor's AI features for code completion and refactoring
Fine-tune your settings.json for optimal workflow
Use the built-in terminal for command-line operations
Browse the VS Code marketplace for additional tools
Remember that while some workflows might be different, Cursor offers powerful AI-assisted coding features that can enhance your productivity beyond traditional IDE capabilities.
# Migrate from VS Code
Source: https://docs.cursor.com/guides/migration/vscode
Guide to migrating VS Code settings, extensions, and profiles to Cursor using one-click import or manual methods
Cursor is based upon the VS Code codebase, allowing us to focus on making the best AI-powered coding experience while maintaining a familiar editing environment. This makes it easy to migrate your existing VS Code settings to Cursor.
## Profile Migration
### One-click Import
Here's how to get your entire VS Code setup in one click:
1. Open the Cursor Settings (⌘/Ctrl + Shift + J)
2. Navigate to General > Account
3. Under "VS Code Import", click the Import button
This will transfer your:
* Extensions
* Themes
* Settings
* Keybindings
### Manual Profile Migration
If you are moving between machines, or want more control over your settings, you can manually migrate your profile.
#### Exporting a Profile
1. On your VS Code instance, open the Command Palette (⌘/Ctrl + Shift + P)
2. Search for "Preferences: Open Profiles (UI)"
3. Find the profile you want to export on the left sidebar
4. Click the 3-dot menu and select "Export Profile"
5. Choose to export it either to your local machine or to a GitHub Gist
#### Importing a Profile
1. On your Cursor instance, open the Command Palette (⌘/Ctrl + Shift + P)
2. Search for "Preferences: Open Profiles (UI)"
3. Click the dropdown menu next to 'New Profile' and click 'Import Profile'
4. Either paste in the URL of the GitHub Gist or choose 'Select File' to upload a local file
5. Click 'Import' at the bottom of the dialog to save the profile
6. Finally, in the sidebar, choose the new profile and click the tick icon to active it
## Settings and Interface
### Settings Menus
Access via Command Palette (⌘/Ctrl + Shift + P), then type "Cursor Settings"
Access via Command Palette (⌘/Ctrl + Shift + P), then type "Preferences: Open Settings (UI)"
### Version Updates
We regularly rebase Cursor onto the latest VS Code version to stay current with features and fixes. To ensure stability, Cursor often uses slightly older VS Code versions.
### Activity Bar Orientation
We made it horizontal to optimize space for the AI chat interface. If you prefer vertical:
1. Open the Command Palette (⌘/Ctrl + Shift + P)
2. Search for "Preferences: Open Settings (UI)"
3. Search for `workbench.activityBar.orientation`
4. Set the value to `vertical`
5. Restart Cursor
# Keyboard Shortcuts
Source: https://docs.cursor.com/kbd
Complete reference for all keyboard shortcuts in Cursor, including Chat, Tab, Terminal and code selection commands
A high level overview of the keyboard shortcuts and keybindings in Cursor. You can see all keyboard shortcuts by pressing `Cmd + R` then `Cmd + S`.
To learn more about Keyboard Shortcuts in Cursor, check out the [Key Bindings for VS Code](https://code.visualstudio.com/docs/getstarted/keybindings) as it serves as a good baseline for Cursor's keybindings.
All of Cursor's keybindings, including those for Cursor-specific features, can be remapped in the Keyboard Shortcuts settings page.
All `Cmd` keys can be replaced with `Ctrl` on Windows.
## General
| Shortcut | Action |
| -------------------------------- | ---------------------------------------- |
| Cmd + I (⌘I) | Toggle Sidepanel (unless binded to mode) |
| Cmd + L (⌘L) | Toggle Sidepan (unless binded to mode) |
| Cmd + . (⌘.) | Open Mode Menu |
| Cmd + / (⌘/) | Loop between AI models |
| Cmd + Shift + J (⌘⇧J) | Open Cursor settings |
| Cmd + , (⌘,) | Open General settings |
| Cmd + Shift + P (⌘⇧P) | Open command palette |
## Chat
These shortcuts work while focused on the chat input box.
| Shortcut | Action |
| --------------------------------------------------- | ---------------------------- |
| Enter | Submit |
| Cmd + Shift + Backspace (⌘⇧⌫) | Cancel generation |
| Cmd + L (⌘L) with code selected | Add selected code as context |
| Cmd + Shift + L (⌘⇧L) with code selected | Add selected code as context |
| Cmd + Enter (⌘⏎) | Accept all changes |
| Cmd + Backspace (⌘⌫) | Reject all changes |
| Tab | Cycle to next message |
| Shift + Tab (⇧⇥) | Cycle to previous message |
| Cmd + Alt + / (⌘⌥/) | Open model toggle |
| Cmd + N (⌘N) / Cmd + R (⌘R) | Create new chat |
| Cmd + Shift + K (⌘⇧K) | Open composer as bar |
| Cmd + \[ (⌘\[) | Open previous chat |
| Cmd + ] (⌘]) | Open next chat |
| Cmd + W (⌘W) | Close chat |
| Esc | Unfocus the field |
## Cmd+K
| Shortcut | Action |
| ---------------------------------------- | ------------------ |
| Cmd + K | Open |
| Cmd + Shift + K | Toggle input focus |
| Enter | Submit |
| Cmd + Shift + Backspace (⌘⇧⌫) | Cancel |
| Option + Enter | Ask quick question |
## Code Selection & Context
| Shortcut | Action |
| ------------------------------------------------ | ------------------------------------ |
| @ | [@-symbols](/context/@-symbols/) |
| # | Files |
| / | Shortcut Commands |
| Cmd + Shift + L | Add selection to Chat |
| Cmd + Shift + K | Add selection to Edit |
| Cmd + L | Add selection to new chat |
| Cmd + M | Toggle file reading strategies |
| Cmd + → | Accept next word of suggestion |
| Cmd + Enter | Search codebase in chat |
| Select code, Cmd + C, Cmd + V | Add copied reference code as context |
| Select code, Cmd + C, Cmd + Shift + V | Add copied code as text context |
## Tab
| Shortcut | Action |
| ------------------ | ----------------- |
| Tab | Accept suggestion |
| Cmd + → | Accept next word |
## Terminal
| Shortcut | Action |
| ---------------------- | ------------------------ |
| Cmd + K | Open terminal prompt bar |
| Cmd + Enter | Run generated command |
| Esc | Accept command |
# AI Commit Message
Source: https://docs.cursor.com/more/ai-commit-message
Learn how to generate contextual Git commit messages automatically using Cursor's sparkle icon or shortcuts
Cursor can help you generate meaningful commit messages for your changes with just a click. Here's how to use this feature:
1. Stage the files you want to commit
2. Open the Git tab in the sidebar
3. Look for the sparkle (✨) icon next to the commit message input field
4. Click the sparkle icon to generate a commit message based on your staged changes
The generated commit message will be based on the changes in your staged files and your repository's git history. This means Cursor will analyze both your current changes and previous commit messages to generate a contextually appropriate message. Cursor learns from your commit history, which means if you use conventions like [Conventional Commits](https://www.conventionalcommits.org/), the generated messages will follow the same pattern.
## Shortcut
You can bind the generate commit message feature to a keyboard shortcut.
1. Go to Keyboard Shortcuts `⌘R ⌘S` or `⌘⇧P` and search for "Open Keyboard Shortcuts (JSON)"
2. Add the following to the file to bind to `⌘M`:
```json
{
"key": "cmd+m",
"command": "cursor.generateGitCommitMessage"
}
```
3. Save the file and you're done!
Currently, there isn't a way to customize or provide specific instructions for
how commit messages should be generated. Cursor will automatically adapt to
your existing commit message style.
# Custom API Keys
Source: https://docs.cursor.com/settings/api-keys
Configure custom API keys for OpenAI, Anthropic, Google and Azure to use your own LLM provider accounts in Cursor
Cursor lets you input your own API keys for various LLM providers to send as many AI messages as you want at your own cost. When a custom API key is used, we will use that when calling the LLM providers.
To use your own API key, go to `Cursor Settings` > `Models` and enter your API keys. Then, click on the "Verify" button. Once your key is validated, your API key will be enabled.
Some Cursor features like Tab Completion
require specialized models and won't work with custom API keys. Custom API
keys only work for features that use standard models from providers like
OpenAI, Anthropic, and Google.
## OpenAI API Keys
You can get your own API key from the [OpenAI platform](https://platform.openai.com/account/api-keys).
OpenAI's reasoning models (o1, o1-mini, o3-mini) require special configuration and are not currently supported with custom API keys.
## Anthropic API Keys
Similar to OpenAI, you can also set your own Anthropic API key so that you will be using claude-based models at your own cost.
## Google API Keys
For Google API keys, you can set your own API key so that you will be using Google models such as `gemini-1.5-flash-500k` at your own cost.
## Azure Integration
Finally, you can also set your own Azure API key so that you will be using Azure OpenAI models at your own cost.
## AWS Bedrock
You can now connect to AWS Bedrock using access keys and secret keys, and enterprises can authenticate using IAM roles.
## FAQ
### Will my API key be stored or leave my device?
Your API key will not be stored, but it will be sent up to our server with every request. All requests are routed through our backend where we do the final prompt building.
### What custom LLM providers are supported?
Cursor only supports API providers that are compatible with the OpenAI API format (like OpenRouter). We do not provide support for custom local LLM setups or other API formats. If you're having issues with a custom API setup that isn't from our supported providers, we unfortunately cannot provide technical support.
# Early Access Program
Source: https://docs.cursor.com/settings/beta
Learn how to join Cursor's Early Access Program to test experimental features and provide feedback
Cursor offers an early access program that gives you early access to new and experimental features. While these features can be exciting, they may be less stable than our standard features.
Beta features are experimental and may contain bugs or unexpected behavior. We recommend staying on standard settings if you need a stable development environment.
## Joining the Early Access Program
To join the early access program and receive pre-release updates:
Access the settings menu from the Cursor application with `CMD+Shift+J` on macOS or `Ctrl+Shift+J` on Windows and Linux.
Find and select the Beta menu in settings sidebar.
Find the 'Update frequency' dropdown and select 'Early Access' to opt in.
Wait for the next early access update to be available, and you will recieve it automatically.
## Leaving the Early Access Program
If you decide you no longer want to be part of the early access program, you can opt out by toggling the 'Update frequency' dropdown to 'Standard' in the settings menu.
Then, either wait for the next update to take effect, or redownload Cursor's latest stable release from [cursor.com](https://cursor.com).
## ⚠️ Warnings
* Beta features are experimental and may contain bugs or unexpected behavior.
* We may be unable to provide support for users on the Early Access version.
* Beta features may change or be removed without notice as we gather feedback and make improvements.
## 💡 Feedback
We value your feedback on beta features. If you encounter any issues or have suggestions, please report bugs through our [Forum](https://forum.cursor.com), making sure to specify that you are on an early access version.
# Models
Source: https://docs.cursor.com/settings/models
Comprehensive guide to Cursor's models: features, pricing, context windows, and hosting details for Chat and CMD+K
## Available models
To add a model to the Chat and ⌘K selection menu, enable it from Cursor Settings > Models.
| Model | Provider | Premium | Agent | Price6 |
| :------------------------------------------------------------------------------------------------------------------------------------------------------------------ | :-------- | :---------: | :---: | :---------------- |
| [`claude-3.7-sonnet`](https://www.anthropic.com/claude/sonnet) | Anthropic | ✓ | ✓ | \$0.04 |
| [`claude-3.7-sonnet`](https://www.anthropic.com/claude/sonnet) MAX 1 | Anthropic | [MAX](#max) | ✓ | \$0.05 |
| [`claude-3.5-sonnet`](https://www.anthropic.com/claude/sonnet) | Anthropic | ✓ | ✓ | \$0.04 |
| [`claude-3.5-haiku`](https://www.anthropic.com/claude/haiku) 2 | Anthropic | ✓ | | \$0.01 |
| [`claude-3-opus`](https://www.anthropic.com/news/claude-3-family) 3 | Anthropic | ✓ | | \$0.10 |
| `cursor-small` | Cursor | | | Free |
| [`deepseek-v3`](https://www.deepseek.com/) | Fireworks | | | Free |
| [`deepseek-r1`](https://www.deepseek.com/) | Fireworks | ✓ | | \$0.04 |
| [`gemini-2.5-pro-exp`](https://blog.google/technology/google-deepmind/gemini-model-thinking-updates-march-2025/) | Google | ✓ | ✓ | \$0.04 |
| [`gemini-2.5-pro-exp`](https://blog.google/technology/google-deepmind/gemini-model-thinking-updates-march-2025/) MAX 1 | Google | [MAX](#max) | ✓ | \$0.05 |
| [`gemini-2.5-flash-preview-04-17`](https://developers.googleblog.com/en/start-building-with-gemini-25-flash/) | Google | | ✓ | Free |
| [`gemini-2.0-pro-exp`](https://blog.google/technology/google-deepmind/gemini-model-updates-february-2025/) | Google | ✓ | | \$0.04 |
| [`gpt-4o`](https://openai.com/index/hello-gpt-4o/) | OpenAI | ✓ | ✓ | \$0.04 |
| [`gpt-4o-mini`](https://openai.com/gpt-4o-mini) 4 | OpenAI | | | Free |
| [`gpt-4.5-preview`](https://openai.com/index/introducing-gpt-4-5/) | OpenAI | | | \$2.00 |
| [`gpt-4.1`](https://openai.com/index/gpt-4-1/) | OpenAI | ✓ | ✓ | \$0.04 |
| [`o1`](https://openai.com/index/learning-to-reason-with-llms/) | OpenAI | | | \$0.40 |
| [`o1-mini`](https://openai.com/index/openai-o1-mini-advancing-cost-efficient-reasoning/) 3 | OpenAI | | | \$0.10 |
| [`o3`](https://openai.com/index/introducing-o3-and-o4-mini/) 5 | OpenAI | | ✓ | \$0.30 |
| [`o3-mini`](https://openai.com/index/openai-o3-mini/) 2, 5 | OpenAI | ✓ | ✓ | \$0.01 |
| [`o4-mini`](https://openai.com/index/introducing-o3-and-o4-mini/) 5 | OpenAI | ✓ | ✓ | Free |
| [`grok-2`](https://x.ai/blog/grok-1212) | xAI | ✓ | | \$0.04 |
| [`grok-3-beta`](https://x.ai/news/grok-3) | xAI | ✓ | ✓ | \$0.04 |
| [`grok-3-mini-beta`](https://x.ai/news/grok-3) | xAI | ✓ | ✓ | Free |
1 Tool calls charged like requests
2 1/3 request
3 10 requests/day included with paid plan
4 500 requests/day with free plan
5 High reasoning effort
6 Prices are higher for [long context window](#large-context-and-pricing) requests
### Premium models
Premium models can be used with the 500 requests included with your monthly Pro or Business subscription.
Once you've exhausted your 500 monthly requests, Cursor will continue to serve you premium model requests, but may delay response time and/or limit access to some models when the platform is under high load.
To avoid delays and limited access, you can enable usage-based pricing for Premium models from [Settings](https://cursor.com/settings) and pay per request after exhausting your monthly allotment of 500.
### Agentic models
Agentic models can be used with Chat's [Agent mode](/chat/agent). These models are highly capable at making tool calls and perform best with Agent.
Submitting an Agent prompt with up to 25 tool calls consumes one request. If your request extends beyond 25 tool calls, Cursor will ask if you'd like to continue which will consume a second request.
### Non-premium models
Those models not designated Premium are pay-as-you-go and can be used by enabling usage-based pricing from [Settings](https://cursor.com/settings). The 500 montly requests cannot be used for these models.
### MAX
Models offered in MAX mode have enhanced capabilities with [larger context windows](#context-windows) and expanded reasoning.
Currently offered as an option for Claude 3.7 Sonnet and Gemini 2.5 Pro, MAX mode provides a 200 Agent tool call limit, the ability to process up to 750 lines per file read operation.
When operated as an Agent, each tool call in MAX mode is charged as a separate request in addition to the initial prompt request.
## Selecting a model
The input interface in Chat and ⌘K includes a model selection menu which lists the models enabled from Settings > Models.
### Auto-select
Enabling Auto-select configures Cursor to select the premium model best fit for the immediate task and with the highest reliability based on current demand. This feature can detect degraded output performance and automatically switch models to resolve it.
### Thinking
Enabling Thinking limits the list of models to reasoning models which think through problems step-by-step and have deeper capacity to examine their own reasoning and correct errors.
These models often perform better on complex reasoning tasks, though they may require more time to generate their responses.
## Context windows
A context window is the maximum span of text and code an LLM can consider at once, including both the input prompt and output generated by the model.
Each Chat session in Cursor maintains its own context window. The more prompts, attached files, and responses included in a session, the larger the context window grows.
Cursor actively optimizes the context window as the Chat session progresses, intelligently pruning non-essential content while preserving critical code and conversation elements.
For best results, it's recommended you take a purpose-based approach to Chat session management, starting a new session for each unique task.
### Large context and pricing
Large context mode allows Cursor to process more text and code per session, handling larger files and complex tasks while maintaining critical context.
Using **large context doubles the request price** compared to standard context sessions. This pricing reflects the increased computational resources required to process and analyze larger amounts of information.
Large context can be enabled in two ways:
* Manually by checking 'Large context' from Settings > Features
* Automatically when a Chat session grows long and/or includes large file attachments; in this case, large context charges will be indicated by a ⚠︎ icon appearing in the input interface
You can monitor per requests costs in real time from the [Settings](https://www.cursor.com/settings) page.
### Context window sizes
| Mode | Context Window |
| :--------------------------------------------------------- | :--------------- |
| `claude-3.7-sonnet` MAX | 200,000 tokens |
| `gemini-2.5-pro-exp` MAX | 1,000,000 tokens |
| `gpt-4.1` | 128,000 tokens |
| `o3` | 128,000 tokens |
| `o4-mini` | 128,000 tokens |
| `gemini-2.5-flash-preview-04-17` | 128,000 tokens |
| `claude-3.7-sonnet` | 120,000 tokens |
| `gemini-2.5-pro-exp` | 120,000 tokens |
| All other models | 60,000 tokens |
| ⌘K | 10,000 tokens |
These thresholds are subject to change as Cursor further optimizes its context capabilities.
## Model hosting
Models are hosted on US-based infrastructure by the model's provider, a trusted partner or Cursor.
When **Privacy Mode** is enabled from Settings, Cursor nor the model providers will store your data with all data deleted after each request is processed. For further details see our [Privacy](/account/privacy), [Privacy Policy](https://cursor.com/privacy), and [Security](https://cursor.com/security) pages.
# Advanced Features
Source: https://docs.cursor.com/tab/advanced-features
Learn to navigate code efficiently using Tab in peek views, prediction, and partial accepts
## Tab in Peek
You can also use Cursor Tab in the "Go to Definition" or "Go to Type Definition" peek views. This is useful, for example, when adding a new argument to a function call.
We especially enjoy using this in vim in conjunction with `gd` to, for example, modify a function definition, then fix all of its usages in one go.
## Cursor Prediction
Cursor can also predict where you will go to after an accepted edit.
If available, you will be able to press tab to go to the next location, allowing you to tab-tab-tab through edits.
## Partial Accepts
You can accept the next word of a suggestion by pressing `Ctrl/⌘` and the right arrow (or by setting `editor.action.inlineSuggest.acceptNextWord` to your preferred keybinding).
To enable partial accepts, navigate to `Cursor Settings` > `Features` > `Cursor Tab`.
# Auto-import
Source: https://docs.cursor.com/tab/auto-import
Learn how Cursor's Tab feature automates module imports in TypeScript and Python projects while you code
## Overview
In TypeScript and Python (beta) project, Tab can automatically import modules and functions from elsewhere in your project, without you having to manually type the import statement.
Just start using the method you want from an existing file, and Tab will automatically suggest the import statement for you. If you accept, the import statement will be added to your file without pulling you away from the code you are writing.
## Troubleshooting
If you are having issues with auto-import, please confirm you have the necessary extensions (e.g. a language server) for your project language, as this is required for auto-import to work.
You can confirm if this is working, by moving your cursor to a function or method that is not yet imported, and hit ⌘ + . or Ctrl + . to see if the import is suggested in the Quick Fix suggestions - if not, then the language server is not working.
# Tab vs GitHub Copilot
Source: https://docs.cursor.com/tab/from-gh-copilot
Compares Cursor's multi-line edits and instruction-based completions to GitHub Copilot's single-line insertions
## Tab Improvements
The biggest difference is the way Cursor and GitHub Copilot complete code.
GitHub Copilot can insert text at your cursor position. It cannot edit the code around your cursor or remove text.
Cursor can insert text at your cursor, and much more:
* Multi-character edits
* Instruction-based edits
Further, Cursor has a history of your recent changes in the context window, so it knows what you are trying to do next.
## Migrate from GitHub Copilot
Since Cursor comes by default with GitHub Copilot, you might have GitHub Copilot and Cursor installed at the same time. We recommend turning off GitHub Copilot when you want to use Cursor.
By default, Cursor takes precedence over GitHub Copilot. If you want to use GitHub Copilot, you can [disable Cursor](/tab/overview#copilot-settings) in the settings.
# Overview
Source: https://docs.cursor.com/tab/overview
Learn how Tab uses AI to suggest multi-line edits, code fixes, and context-aware completions directly in the editor
Cursor Tab is our native autocomplete feature. It's a more powerful Copilot that suggests entire diffs with especially good memory.
Powered by a custom model, Cursor Tab can:
* Suggest edits around your cursor, not just insertions of additional code.
* Modify multiple lines at once.
* Make suggestions based on your recent changes and linter errors.
Free users receive 2000 suggestions at no cost. Pro and Business plans receive unlimited suggestions.
## UI
When Cursor is only adding additional text, completions will appear as grey text. If a suggestion modifies existing code,
it will appear as a diff popup to the right of your current line.
You can accept a suggestion by pressing `Tab`, or reject it by pressing `Esc`. To partially accept a suggestion word-by-word, press `Ctrl/⌘ →`.
To reject a suggestion, just keep typing, or use `Escape` to cancel/hide the suggestion.
Every keystroke or cursor movement, Cursor will attempt to make a suggestion based on your recent changes. However, Cursor will not always show a suggestion; sometimes the model has predicted that there's no change to be made.
Cursor can make changes from one line above to two lines below your current line.
## Toggling
To turn the feature on or off, hover over "Cursor Tab" icon on the status bar in the bottom right of the application.
## Keyboard Shortcut
Bind Cursor Tab to a custom keyboard shortcut by selecting Settings > Keyboard Shortcuts from the Cursor menu and searching for `Accept Cursor Tab Suggestions`.
## FAQ
### Tab gets in the way when writing comments, what can I do?
You can disable Cursor Tab for comments by going to `Cursor Settings` > `Tab Completion` and unchecking "Trigger in comments".
# Common Issues
Source: https://docs.cursor.com/troubleshooting/common-issues
Guide to resolving common Cursor issues including networking, resource usage, SSH connections, and general FAQs
While we strive to make Cursor as stable as possible, sometimes issues can arise. Below are some common issues and how to resolve them.
### Networking Issues (HTTP/2)
Cursor relies on the HTTP/2 protocol for many of it's AI features, due to it's ability to handle streamed responses. If HTTP/2 is not supported by your network, this can cause issues such as failure to index your code, and the inability to use Cursor's AI features.
This can be the case when on corpoorate networks, using VPNs, or using a proxy like Zscaler.
To resolve this, Cursor now comes with a HTTP/1.1 fallback, which is slower, but will allow you to use Cursor's AI features. You can enable this yourself in the app settings (not the Cursor settings), by pressing `CMD/CTRL + ,` and then searching for `HTTP/2`.
You should then enable the `Disable HTTP/2` option, which will force Cursor to use HTTP/1.1, and should resolve the issue.
We hope to add automatic detection and fallback in the future!
### Resource Issues (CPU, RAM, etc.)
Some users see high CPU or RAM usage in Cursor, which can cause their machine to slow down, or to show warnings about high RAM usage.
While Cursor can use a lot of resources when working on large codebases, this is usually not the case for most users, and is more likely to be an issue with Cursor's extensions or settings.
If you are seeing a low RAM warning on **MacOS**, please note that there is a bug for some users that can show wildly incorrect values. If you are seeing this, please open the Activity Monitor and look at the "Memory" tab to see the correct memory usage.
If you're experiencing high CPU or RAM usage in Cursor, here are steps to diagnose and resolve the issue:
While many extensions can be useful, some can significantly impact performance!
To test this, you can try to run `cursor --disable-extensions` from the command line to launch Cursor without any extensions enabled. If the performance improves, gradually re-enable extensions one by one to identify the problematic ones.
You can also try to use the Extension Bisect feature, which will help you identify which extension is causing the issue. You can read more about it [here](https://code.visualstudio.com/blogs/2021/02/16/extension-bisect#_welcome-extension-bisect), but note that this may only be useful if the issues are immediate and obvious, and not an issue that worsens over time.
The **Process Explorer** is a built in tool in Cursor that allows you to see which processes are consuming resources.
To open it, open the Command Palette (`Cmd/Ctrl + Shift + P`) and run the `Developer: Open Process Explorer` command.
This should open a new window, with a list of all the processes Cursor is running, both as part of it's own executation, as well as any processes needed to run extensions and any terminals you may have running. This should immediately identify any processes that are consuming a lot of resources.
If the process is listed under the **`extensionHost`** dropdown, this suggests an extension is causing the issue, and you should try to find and disable the problematic extension.
If the process is listended under the **`ptyHost`** dropdown, this suggests a terminal is consuming a lot of resources. The Process Explorer will show you each terminal that is running, and what command is running within it, so that you can try to kill it, or diagnose it's high resource usage.
If the usage is from another process, please let us know in the [forum](https://forum.cursor.com/) and we'll be happy to help diagnose the issue.
Depending on your operating system, you can use a number of different tools to monitor your system's resources.
This will help you identify if the issue is Cursor-specific, or if it's a system-wide issue.
While the above steps should help the majority of users, if you are still experiencing issues, you can try testing a minimal installation of Cursor to see if the issue persists.
## General FAQs
If the update is very new, it might not have rolled out to you yet. We do staged rollouts, which means we release new updates to a few randomly selected users first before releasing them to everyone. Expect to get the update in a couple days!
You can try using the `Sign Out of GitHub` command from the command palette `Ctrl/⌘ + Shift + P`.
Unfortunately, we don't support GitHub Codespaces yet.
Currently, we don't support SSHing into Mac or Windows machines. If you're not using a Mac or Windows machine, please report your issue to us in the [forum](https://forum.cursor.com/). It would be helpful to include some logs for better assistance.
If you encounter the error "SSH is only supported in Microsoft versions of VS Code", follow these steps:
1. Uninstall the current Remote-SSH extension:
* Open the Extensions view (`Ctrl + Shift + X`)
* Search for "Remote-SSH"
* Click on the gear icon and select "Uninstall"
2. Install version 0.113 of Remote-SSH:
* Go to the Cursor marketplace
* Search for "Remote-SSH"
* Find version 0.113 and install it
3. After installation:
* Close all VS Code instances that have active SSH connections
* Restart Cursor completely
* Try connecting via SSH again
If you still experience issues, make sure your SSH configuration is correct and that you have the necessary SSH keys set up properly.
Cursor Tab and Cmd K use HTTP/2 by default, which allows us to use less resources with lower latency. Some corporate proxies (e.g. Zscaler in certain configurations) block HTTP/2. To fix this, you can set `"cursor.general.disableHttp2": true` in the settings (`Cmd/Ctrl + ,` and then search for `http2`).
Try logging out and logging back in from the Cursor Settings
If you're subscribed to Pro you can click on `Manage Subscription` from the [Dashboard](https://cursor.com/settings) and your plan renewal date will be displayed at the top.
If you're a free user you can check when you got the first email from us in your inbox. Your usage will reset every month from that date.
If you notice that your Chat or Composer history has been cleared following an update, this is likely due to low disk space on your system. Cursor may need to clear historical data during updates when disk space is limited. To prevent this from happening:
1. Ensure you have sufficient free disk space before updating
2. Regularly clean up unnecessary files on your system
3. Consider backing up important conversations before updating
You can follow [this guide](https://code.visualstudio.com/docs/setup/uninstall) to uninstall Cursor. Replace every occurrence of "VS Code" or "Code" with "Cursor", and ".vscode" with ".cursor".
You can delete your account by clicking on the `Delete Account` button in the [Dashboard](https://cursor.com/settings). Note that this will delete your account and all data associated with it.
You can open Cursor from the command line by running `cursor` in your terminal. If you're missing the `cursor` command, you can
1. Open the command palette `⌘⇧P`
2. Type `install command`
3. Select `Install 'cursor' command` (and optionally the `code` command too which will override VS Code's `code` command)
If you click Sign In on the General tab of Cursor's Settings tab but are redirected to cursor.com and then return to Cursor still seeing the Sign In button, try disabling your firewall or antivirus software, which may be blocking the sign-in process.
# Getting a Request ID
Source: https://docs.cursor.com/troubleshooting/request-reporting
Learn how to find and share request IDs in Cursor for better technical support and issue reporting
When the Cursor team are investigating a technical issue, sometimes, we may ask you to provide us with a "request ID".
## What is a request ID?
A request ID is a unique identifier that is generated when you submit a request to Cursor. It is a string of characters that is used to identify the request in our internal systems.
It usually follows a randomized format, such as: `8f2a5b91-4d3e-47c6-9f12-5e8d94ca7d23`.
## How do I find a request ID?
Request IDs are highly limited when Privacy Mode is enabled, so we recommend disabling Privacy Mode when reporting an issue.
As a reminder, users on a business plan have Privacy Mode enabled by default, by their organization's admin.
### Getting your current request ID
If you are wanting to report an issue with your current or very recent conversation, you can do this in just a few clicks.
With the relevant conversation open in the Chat sidebar, you can use the context menu in the top right to see a few options - one of these options is the `Copy Request ID` option.
After copying the request ID, you can send it back to us to look into, either via the forum, or by email if requested by our support team.
### Getting a request ID from a previous action
You can retrieve a historical request ID from within Cursor by running the `Report AI Action` command.
You you can do this by:
1. Opening the command palette `⌘⇧P`
2. Typing `Report AI Action`
3. Selecting the `Report AI Action` option
This will open a new popup, listing your most recent AI actions across Chat, CMD+K and Apply.
Select the action you want to report, by matching the time and feature the action was used in. Once you select the action, you have the option to copy the request ID to your clipboard. With it copied, you can send it back to us to look into!
# Troubleshooting Guide
Source: https://docs.cursor.com/troubleshooting/troubleshooting-guide
Guide to troubleshooting common Cursor issues, resetting app data, and submitting detailed bug reports
Sometimes, Cursor may unexpectantly have some issues. This can be due to a number of reasons, including extensions, app data, or your system. While we work hard to ensure Cursor is as stable out of the box as possible, if these issues happen, you can try the following steps to resolve them.
Steps to report an issue to the Cursor team
## Troubleshooting
### 1. Extension Data
If you are experiencing issues with individual extensions, you can try uninstalling and reinstalling them to reset any data they may have stored. Also check your settings to see if you have any configuration for the extensions that would remain after uninstalling and reinstalling them.
### 2. Clearing App Data
WARNING:
This will delete your app data, including your extensions, themes, snippets and any other data related to your installation. Consider exporting your profile to ensure this data is not lost.
To allow your installation to be restored between updates, and between reinstallation, Cursor keeps your app data outside of the app itself. This means that if you uninstall Cursor, you can reinstall it and it will restore your app data from the previous installation.
If you would like to clear your app data, you can do so by following these steps:
**Windows:** Run the following commands in Command Prompt:
```txt
rd /s /q %USERPROFILE%\AppData\Local\Programs\cursor*
rd /s /q %USERPROFILE%\AppData\Local\Cursor*
rd /s /q %USERPROFILE%\AppData\Roaming\Cursor*
rd /s /q %USERPROFILE%\cursor*
```
**MacOS:** Run `sudo rm -rf ~/Library/Application\ Support/Cursor` and `rm -f ~/.cursor.json` in Terminal.
**Linux:** Run `rm -rf ~/.cursor ~/.config/Cursor/` in Terminal.
### 3. Uninstalling Cursor
While we never want you to have to reinstall Cursor, if you are experiencing issues, this can sometimes help.
To uninstall the Cursor app, you can do the following:
Search for `Add or Remove Programs` Start Menu, find "Cursor" list, and click "Uninstall".
Open the Applications folder, find "Cursor" in the list, and right click and select "Move to Trash".
Find the location of the Cursor.appimage file, and delete it.
### 4. Reinstalling Cursor
If you have uninstalled Cursor, you can reinstall it by going to the [Downloads page](https://www.cursor.com/download) and downloading the latest version. If you have not cleared your app data, this should restore your app to the state it was in when you uninstalled it. Otherwise, you will have an entirely fresh install of Cursor.
## Reporting an Issue
If the above steps don't help, please let us know in the [forum](https://forum.cursor.com/) and we'll be happy to help diagnose the issue.
Report an bug or issue on the Cursor forum
For the best chance at a quick resolution, please provide as much of the following information as you can, to help the team resolve the issue for you and othersß∂:
Capture a screenshot of the issue, making sure to redact any sensitive information.
Document the exact steps needed to reproduce the issue.
Retrieve system information from:
`Cursor` > `Help` > `About`
Click to view our guide on gathering request IDs
Check developer tools console errors, by running this in the command palette:
`Developer: Toggle Developer Tools`
Access Cursor's logs by running this in the command palette:
`Developer: Open Logs Folder`