::-webkit-scrollbar {
  width: 6px;
}

::-webkit-scrollbar-track {
  background: white;
}

::-webkit-scrollbar-thumb {
  background-color: #eeee;
  border-radius: 10px;
  border: none;
}

html {
  scrollbar-width: thin;
  scrollbar-color: #eeee white;
  scrollbar-gutter: stable;
}

html.dark {
  scrollbar-width: thin;
  scrollbar-color: #222 #222;
  scrollbar-gutter: stable;
}

html.dark ::-webkit-scrollbar-track {
  background: #222;
}

html.dark ::-webkit-scrollbar-thumb {
  background-color: #222;
}

html.dark ::-webkit-scrollbar-thumb:hover {
  background-color: #333;
}

a:has(> code) {
  border-bottom: none !important;
}

a>code {
  cursor: pointer;
  border-bottom: #0c0c15 1px solid !important;
}

a>code:hover {
  border-bottom: #0c0c15 2px solid !important;
}

#content-area>div.leading-6.mt-14>footer>div.sm\:flex>a {
  display: none;
}

* {
  /* Use system font stack as the default font */
  font-family: -apple-system, BlinkMacSystemFont, sans-serif;
  /* Disable all font-feature-settings */
  font-feature-settings: normal;
}

/* h1,
h2,
h3,
h4,
h5,
h6, */
code * {
  font-family: monospace;
}

#header h1 {
  font-size: 2.25rem;
}

/* #content-container h2 {
  font-size: 2rem;
}

#content-container h3 {
  font-size: 1.75rem;
}

#content-container h4 {
  font-size: 1.25rem;
} */

.full-width-table table {
  display: table;
}

.full-width-table table th {
  text-align: left;
  white-space: nowrap;
  overflow: hidden;
  text-overflow: ellipsis;
}

.full-width-table table th:nth-child(3),
.full-width-table table th:nth-child(4),
.full-width-table table th:nth-child(5) {
  text-align: center;
}

@media (max-width: 640px) {

  .full-width-table table th:nth-child(2),
  .full-width-table table td:nth-child(2) {
    display: none;
  }
}



:not(.dark) .prose :where(a):not(:where([class~=not-prose], [class~=not-prose] *)):not(h1, h1 *, h2, h2 *, h3, h3 *, h4, h4 *, h5, h5 *, h6, h6 *) {
  border-bottom: #666666 1px solid;
}


/* img {
  border-radius: 0.5rem;
} */

.max-pill {
  background-color: white;
  color: #0c0c15;
  padding: 1px 4px;
  border-radius: 8px;
  font-size: 0.6rem;
  font-weight: 500;
  display: inline-block;
  margin-left: 2px;
  margin-right: 4px;
  line-height: 1.2;
  border: 1px solid #0c0c15;
}

.dark .max-pill {
  background-color: #0c0c15;
  color: white;
  border-color: white;
}

.footnotes-container {
  display: grid;
  grid-template-columns: 1fr 1fr;
  grid-auto-flow: row;
  margin-top: -14px;
  padding-bottom: 1rem;
  border-bottom: 1px solid rgb(var(--gray-800)/.5);
  line-height: 1.6;
}

@media (max-width: 640px) {
  .footnotes-container {
    grid-template-columns: 1fr;
  }
}


.footnotes-container p {
  font-size: 0.8rem;
  opacity: 0.9;
  margin: 0 0 0 0.35em;
}

.dark .footnotes-container {
  border-bottom-color: rgb(var(--gray-800)/.5);
}

.no-wrap {
  white-space: nowrap;
}

.flowchart {
  margin: 0 auto;
}

#mcp-servers {
  max-width: 52rem;
  padding: 1rem;
  margin: 0 auto;
}

#mcp-servers .card h2 {
  font-size: 1.25rem;
}

#mcp-servers .card>div {
  height: 100%;
  display: flex;
  flex-direction: column;
}

#mcp-servers .card>div>div:last-child {
  flex: 1;
  display: flex;
  flex-direction: column;
}

#mcp-servers .card>div>div>div {
  flex: 1;
  display: flex;
  gap: 1rem;
  align-items: flex-start;
  flex-direction: column;
  justify-content: space-between;
}

.mcp-install-examples img {
  margin: 0;
}

html.dark .server-icon svg:not(.no-invert) [fill="white"] {
  fill: black;
}

/* Chat Assistant Sheet - Solid background for better visibility */
#chat-assistant-sheet {
  background-color: white;
}

html.dark #chat-assistant-sheet {
  background-color: #0c0c15;
}

#!/usr/bin/env node

import chokidar from 'chokidar';
import { fileURLToPath } from 'url';
import { dirname, join } from 'path';
import { generateOgForFiles } from './generate-og-image.tsx';

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);

console.log('👀 Watching MDX files for OG image generation...');

// Watch all .mdx files, ignoring node_modules
const watcher = chokidar.watch('**/*.mdx', {
  ignored: ['node_modules/**', '.git/**'],
  persistent: true,
  cwd: join(__dirname, '..')
});

async function generateOgImage(filePath) {
  console.log(`🖼️  Generating OG image for: ${filePath}`);

  try {
    await generateOgForFiles([filePath]);
    console.log(`✅ OG image generated for: ${filePath}`);
  } catch (error) {
    console.error(`❌ Failed to generate OG image for: ${filePath}`, error);
  }
}

watcher.on('change', generateOgImage);
watcher.on('add', generateOgImage);

watcher.on('ready', () => {
  console.log('✅ OG image watcher ready');
});

watcher.on('error', (error) => {
  console.error('❌ OG image watcher error:', error);
}); 

How do rate limits work?

Can I use Max Mode as part of my rate limits?

How much compute do I get?

How do you offer this much compute?

What if I hit a limit?

If I flip on usage-based pricing for requests that exceed rate limits, how is cost per request calculated?

What if I’d like just a lumpsum of requests?

What if I’m on a Team Plan?

Cursor meters rate limits based on underlying compute usage, and limits reset every few hours.

Cursor – Rate Limits

Rate Limits

Cursor

globe

newspaper

headset

Get started with Cursor and learn core features

Cursor – Welcome to Cursor

Welcome to Cursor

Guide to installing Cursor, configuring initial settings, and migrating from other code editors

Cursor – Installation

Installation

Common questions about language support, models, project limits, and data management in Cursor with troubleshooting help

Cursor – FAQ

Overview of asynchronous remote agents in Cursor

How to use background agents to parallelize your work.

Cursor – Background Agents

Background Agents

Learn how to index your codebase in Cursor for more accurate AI assistance and search results

Cursor – Codebase Indexing

Codebase Indexing

Control how the Agent model behaves with reusable, scoped instructions.

Cursor – Rules

Rules

Use the context menu to quickly access and manage your codebase

Cursor – Managing Context

Managing Context

Control which files Cursor's AI features and indexing can access using .cursorignore and .cursorindexingignore

Cursor – Ignore Files

Ignore Files

Connect external tools and data sources to Cursor using the Model Context Protocol (MCP) plugin system

Cursor – Model Context Protocol

Model Context Protocol

Experience enhanced AI capabilities with Max Mode in Cursor

Cursor – Max Mode

Max Mode

Cursor – BugBot

BugBot

Cursor – Slack

Slack

Guide to Cursor usage tiers, request types, quotas, and billing options for models and team accounts

Cursor – Plans & Usage

Plans

Available models in Cursor and their pricing

Cursor – Models & Pricing

Models

Learn how to manage billing, usage pricing, and team settings in the dashboard for different plans

Cursor – Dashboard

Dashboard

Complete guide to managing Cursor billing: subscriptions, refunds, cycles and access through Stripe portal

Cursor – Billing

Billing

Privacy

Security

Configure custom API keys for OpenAI, Anthropic, Google and Azure to use your own LLM provider accounts in Cursor

Cursor – Custom API Keys

Custom API Keys

Learn how to join Cursor's Early Access Program to test experimental features and provide feedback

Cursor – Early Access Program

Early Access Program

Guide to resolving common Cursor issues including networking, resource usage, SSH connections, and general FAQs

Cursor – Common Issues

Common Issues

Guide to troubleshooting common Cursor issues, resetting app data, and submitting detailed bug reports

Cursor – Troubleshooting Guide

Troubleshooting Guide

Learn how to find and share request IDs in Cursor for better technical support and issue reporting

Cursor – Getting a Request ID

Getting a Request ID

Cursor – Working with Context

Working with Context

How to select models based on your task at hand

Cursor – Selecting Models

Selecting Models

Cursor – Web Development

Web Development

Learn to generate architectural diagrams using Mermaid to visualize system structure and data flow

Cursor – Architectural Diagrams

Architectural Diagrams

How to work with large codebases in Cursor

Cursor – Large Codebases

Large Codebases

How to leverage documentation effectively in Cursor through prompting, external sources, and internal context

Cursor – Working with Documentation

Working with Documentation

Guide to migrating VS Code settings, extensions, and profiles to Cursor using one-click import or manual methods

Cursor – VS Code

VS Code

Guide to migrating from JetBrains IDEs to Cursor: setup extensions, themes, shortcuts, and language-specific tools

Cursor – JetBrains

JetBrains

Comprehensive guide to setting up Python development in Cursor with essential extensions, linting and tools

Cursor – Python

Python

Complete guide to JavaScript & TypeScript development in Cursor, featuring extensions, AI tools, and framework support

Cursor – JavaScript & TypeScript

JavaScript & TypeScript

Guide to integrating Cursor with Swift development workflows using Xcode, hot reloading, and Sweetpad tools

Cursor – iOS & macOS (Swift)

iOS & macOS (Swift)

Complete guide to setting up Java development in Cursor: JDK setup, extensions, debugging, and Maven/Gradle integration

Cursor – Java

Java

book-open

Explore and install MCP servers for Cursor

Cursor – MCP Directory

MCP Directory

Get started with Cursor IDE & learn core features: Tab completion, Chat AI pair programming, and Cmd-K editing

Learn about Cursor's core AI features, settings, and customization options for powerful code development.

Cursor – Introduction

Introduction

Cursor – Migrate from VS Code

Migrate from VS Code

Cursor – Migrate from JetBrains IDEs

Migrate from JetBrains IDEs

Learn how Tab uses AI to suggest multi-line edits, code fixes, and context-aware completions directly in the editor

Cursor – Overview

Overview

Compares Cursor's multi-line edits and instruction-based completions to GitHub Copilot's single-line insertions

Cursor – Tab vs GitHub Copilot

Tab vs GitHub Copilot

Learn how Cursor's Tab feature automates module imports in TypeScript and Python projects while you code

Cursor – Auto-import

Auto-import

Learn to navigate code efficiently using Tab in peek views, prediction, and partial accepts

Cursor – Advanced Features

Advanced Features

Natural language interface for exploring, editing, and managing code with contextual AI assistance in Chat mode

Autonomous AI coding agent that independently explores, plans, and executes complex codebase changes with full tools

Cursor – Agent Mode

Agent Mode

Ask mode lets you explore and learn about codebases through AI search and queries without making changes

Cursor – Ask mode

Ask mode

Make precise code changes with explicit file targeting - a focused editing mode with user-controlled tooling

Cursor – Manual Mode

Manual Mode

Create custom Cursor modes with tailored tools and prompts to personalize AI assistance for specific workflows

Cursor – Custom Modes

Custom Modes

A guide to all available tools in Cursor's Chat modes for searching, editing, and interacting with your codebase

Cursor – Tools

Tools

Learn how to apply, accept, or reject code suggestions from chat using Cursor's Apply feature

Cursor – Apply

Apply

Learn how to use Cmd/Ctrl K in Cursor to generate, edit code and ask questions with the Prompt Bar

Use Cmd K in Cursor terminal to generate and run commands through a prompt bar interface

Cursor – Terminal Cmd K

Terminal Cmd K

Learn how to generate contextual Git commit messages automatically using Cursor's sparkle icon or shortcuts

Cursor – AI Commit Message

AI Commit Message

A guide to using Notepads in Cursor for sharing context between Composers and Chat interactions

Cursor – Notepads (Beta)

Notepads (Beta)

Complete reference for all keyboard shortcuts in Cursor, including Chat, Tab, Terminal and code selection commands

Cursor – Keyboard Shortcuts

Keyboard Shortcuts

Guide to using @ symbols in Cursor for referencing code, files, documentation and other context in chats

Learn how to reference files using @ in Cursor's Chat and Cmd K, with preview and chunking features

Cursor – @Files

@Files

Reference folders as context in Chat & Composer for enhanced AI conversations

Cursor – @Folders

@Folders

Learn how to reference code snippets in Cursor using @Code symbol and keyboard shortcuts for adding to Chat

Cursor – @Code

@Code

Learn how to use, add, and manage custom documentation as context in Cursor using @Docs

Cursor – @Docs

@Docs

Reference Git commits, diffs, and PRs as context in Cursor Chat to analyze changes and generate commit messages

Cursor – @Git

@Git

Enables web search to dynamically add recent online information and documentation as context in Cursor commands

Cursor – @Web

@Web

Add nearby code definitions to Cmd K context using the @Definitions symbol

Cursor – @Definitions

@Definitions

Learn how to include and manage web links as context in Cursor's AI features by pasting URLs

Cursor – @Link

@Link

Access and reference linting errors in your codebase

Cursor – @Lint Errors

@Lint Errors

Reference recently modified code as context for AI chat using the @Recent Changes symbol

Get Started

Editor

Context

Integrations

Account

Settings

Troubleshooting

Rate Limits

How do rate limits work?

Can I use Max Mode as part of my rate limits?

How much compute do I get?

How do you offer this much compute?

What if I hit a limit?

If I flip on usage-based pricing for requests that exceed rate limits, how is cost per request calculated?

What if I’d like just a lumpsum of requests?

What if I’m on a Team Plan?

Get Started

Editor

Context

Integrations

Account

Settings

Troubleshooting

​How do rate limits work?

​Can I use Max Mode as part of my rate limits?

​How much compute do I get?

​How do you offer this much compute?

​What if I hit a limit?

​If I flip on usage-based pricing for requests that exceed rate limits, how is cost per request calculated?

​What if I’d like just a lumpsum of requests?

​What if I’m on a Team Plan?

How do rate limits work?

Can I use Max Mode as part of my rate limits?

How much compute do I get?

How do you offer this much compute?

What if I hit a limit?

If I flip on usage-based pricing for requests that exceed rate limits, how is cost per request calculated?

What if I’d like just a lumpsum of requests?

What if I’m on a Team Plan?