Claude Desktop takes everything available in Claude Web and adds three capabilities that fundamentally change how you manage context: MCP server connections that link Claude to external tools and data sources, direct local file access that eliminates the upload-download cycle, and Computer Use that lets Claude interact with your desktop environment. These additions make Claude Desktop the right choice when your work requires live data, local file system access, or integration with tools that Claude Web cannot reach.

This guide explains how to leverage each of Claude Desktop's context management features, when to use them, and how they complement the Projects, artifacts, and conversation patterns covered in the Claude Web guide.

What Claude Desktop Adds Over Claude Web

Claude Desktop shares the same core features as Claude Web: Projects with instructions and knowledge files, artifacts, and the same large context windows (up to 1 million tokens). The key additions are:

If your work is purely knowledge-based (writing, research, analysis), Claude Web is sufficient. Switch to Claude Desktop when you need to connect Claude to your local environment or external services.

MCP Servers: The Core Differentiator

The Model Context Protocol (MCP) is what makes Claude Desktop a genuinely different tool from the web interface. MCP is an open standard that allows Claude to connect to external services, databases, file systems, and tools through standardized server implementations.

How MCP Works in Claude Desktop

Claude Desktop acts as the MCP host. You configure MCP servers in the application settings, and Claude gains access to the tools those servers expose. When Claude needs information from an external source, it calls the appropriate MCP tool, receives the results, and incorporates them into its response.

Practical MCP Use Cases

Database Access: Connect a database MCP server to let Claude query your development database directly. Instead of copying and pasting query results, Claude can run queries itself:

• Explore schema to understand your data model
• Run diagnostic queries when debugging
• Verify data after explaining a migration plan

File System Access: Connect a filesystem MCP server to give Claude access to specific directories on your machine. This is especially useful for:

• Browsing project directories without manually uploading each file
• Reading configuration files, logs, or data files
• Writing output files (reports, generated code, processed data) directly to disk

Version Control: Connect a Git MCP server to let Claude interact with your repository:

• Review recent commits and diffs
• Understand the project's change history
• Create branches or commits (with your approval)

API Integration: Connect MCP servers for services your workflow depends on:

• Jira or Linear for project management context
• Notion or Confluence for internal documentation
• Slack for team communication context

Setting Up MCP Servers

MCP servers are configured in Claude Desktop's settings as JSON:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-filesystem", "/path/to/project"]
    },
    "postgres": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://user:pass@localhost:5432/mydb"
      }
    }
  }
}

When to Use MCP

Use MCP when:

• Your task requires data that is not (and should not be) in the conversation or project files
• You need Claude to interact with live systems (databases, APIs, file systems)
• You want Claude to verify its work against real systems
• The data changes frequently and uploading snapshots is impractical

Do not use MCP when:

• The task is self-contained (writing, brainstorming, planning)
• You can provide the needed context by pasting or uploading files
• You are working with sensitive production systems (connect to dev/staging only)
• The MCP server adds latency that slows your workflow

MCP Security Considerations

MCP servers run locally and can access real systems. Best practices:

• Only connect to development or staging environments, never production
• Use read-only database credentials when possible
• Limit filesystem access to specific directories using the server's configuration
• Review Claude's MCP calls before approving actions that modify data
• Use environment variables for credentials rather than hardcoding them in configuration
• Audit your MCP server configurations periodically to remove servers you no longer use

Choosing the Right MCP Servers

Not every project needs every MCP server. Start with the minimum set and add more as your workflow demands:

Solo developers: Filesystem + database (if applicable) Frontend developers: Filesystem + browser automation (Playwright) Backend developers: Filesystem + database + API testing Full-stack teams: Filesystem + database + Git + project management

Adding servers you do not actively use wastes Claude's attention. Each connected server expands the list of available tools Claude must evaluate for every request.

Computer Use: Desktop-Level Interaction

Computer Use (currently in beta) allows Claude to interact with your desktop environment by capturing screenshots, controlling the mouse, and providing keyboard input. This enables Claude to use applications that do not have APIs or MCP servers.

When Computer Use Helps with Context

Computer Use is a context-gathering tool in addition to being an interaction tool. Sometimes the easiest way to give Claude context is to let it look at what you are looking at:

• GUI applications: Show Claude your IDE, database tools, or monitoring dashboards
• Web applications: Let Claude navigate internal tools that require authentication
• Design tools: Have Claude reference designs in Figma or Sketch directly
• Spreadsheets: Let Claude read complex Excel layouts that do not convert cleanly to CSV

Practical Workflow

1. Ask Claude to take a screenshot of the current screen
2. Claude analyzes the visual context and incorporates it into the conversation
3. You can direct Claude to interact with specific UI elements

This is particularly useful when the relevant context is in a visual format that is difficult to describe in text.

Computer Use Limitations

Computer Use is slower than MCP-based interactions because it relies on visual processing rather than structured data exchange. Use it as a fallback for tools that lack MCP servers or APIs, not as your primary context mechanism. For anything that can be done through MCP (database queries, file access, API calls), MCP is faster and more reliable.

Local File Access: Eliminating the Upload Cycle

Claude Desktop can read from and write to your local file system directly (via MCP filesystem server), eliminating the need to manually upload and download files.

Advantages Over Web Uploads

• No file size workarounds: Access files of any size without upload limits
• Live files: Claude reads the current version of a file, not a snapshot uploaded hours ago
• Write capability: Claude can save outputs directly to your file system
• Directory browsing: Claude can explore project structures to understand organization

Best Practices for Local File Access

• Scope access narrowly. Point the filesystem MCP server at the specific project directory, not your home folder.
• Use it for exploration. Let Claude browse your project structure to build understanding, then focus on specific files.
• Combine with Projects. Use Project instructions to set context and local file access to provide the actual content. This gives Claude both the "how" (instructions) and the "what" (files).

External Documents: PDFs and Markdown in Claude Desktop

Claude Desktop handles external documents the same way as Claude Web: through Project knowledge files and conversation uploads. However, the addition of local file access changes the strategy.

The Hybrid Approach

For persistent reference material: Upload to Project knowledge files (PDFs or Markdown). These are always available in every conversation within the Project.

For working documents: Access via the filesystem MCP server. This way Claude reads the live version of your files without requiring re-uploads when content changes.

For published specifications: Upload PDFs to Project knowledge files. These do not change, so the snapshot approach works fine.

For your own documentation: Keep it in Markdown files on disk and access via MCP. This way both you and Claude are always working with the latest version.

Building an Effective Claude Desktop Workflow

Step 1: Set Up Your Project

Create a Claude Desktop Project with:

• Project Instructions covering your role, style, constraints, and terminology
• Knowledge files for stable reference material (style guides, specifications, standards)

Step 2: Configure MCP Servers

Add MCP servers for the external systems you work with regularly:

• Filesystem server pointing at your project directory
• Database server connected to your development database (if applicable)
• Any service-specific MCP servers for tools you use daily

Step 3: Use the Right Tool for Each Context Need

Step 4: Manage Conversation Threads

Even with MCP and local file access, conversation management matters:

• Start new conversations for new topics (Project context persists)
• Use artifacts for important outputs you want to reference later
• Summarize progress when starting fresh threads

Advanced Patterns

The Live Debugging Pattern

When debugging an issue:

1. Let Claude read the relevant source code via filesystem MCP
2. Let Claude query the database to check data state
3. Let Claude read log files to identify error patterns
4. Have a conversation where Claude synthesizes all of this context into a diagnosis

This approach gives Claude real-time access to a broader context than you could reasonably paste into a conversation.

The Document Generation Pipeline

For creating documents that reference live data:

1. Claude reads data via MCP (database stats, API responses, configuration)
2. Claude generates the document in a conversation
3. Claude writes the output directly to a file on disk
4. You review and iterate

This eliminates the copy-paste cycle between Claude and your file system.

The Research and Synthesis Pattern

For research projects spanning multiple sources:

1. Upload academic papers and specifications as Project knowledge files
2. Connect a web-search MCP server for current information
3. Use filesystem MCP to read your existing notes and drafts
4. Claude synthesizes across all sources, referencing each by name

Common Mistakes

1. Connecting production databases. Always use development or staging credentials. Even read-only production access introduces risk.

2. Over-scoping filesystem access. Do not give Claude access to your entire home directory. Point the filesystem server at the specific project folder.

3. Using MCP for everything. If you just need Claude to reference a style guide, upload it to Project knowledge files. MCP is for live, changing data.

4. Forgetting Project Instructions. MCP and local file access do not replace the need for clear instructions. Claude still needs to know your style, constraints, and output format.

5. Not reviewing MCP actions. When Claude performs actions through MCP (writing files, running queries), review them. The protocol provides transparency, but you need to exercise your approval authority.

Go Deeper

To learn more about context management strategies for AI tools and agentic workflows, check out these resources by Alex Merced:

• The 2026 Guide to AI-Assisted Development covers AI-assisted development workflows, prompt engineering, and context strategies for software engineers.

• The 2026 Guide to Lakehouses, Apache Iceberg and Agentic AI explores how AI agents are reshaping data architecture and how to build systems that support agentic workflows.

And for a fictional take on where AI is heading:

• The Emperors of A.I. Valley: A Novel of Power, Code, and the War for the Future is a novel about the power struggles and ethical dilemmas behind the companies building the most powerful AI systems in the world.