Intelligent Operations

The Problem

Claude Desktop has a critical limitation: file operations timeout or fail with files larger than ~50KB.

When you ask Claude to read, write, or edit a large file using standard tools:

The operation starts
After 30 seconds, it times out
Claude gets stuck or the operation fails silently
You lose work or get corrupted files

This happens because standard file operations try to load the entire file into memory at once, which overwhelms Claude Desktop’s connection.

The Solution: Intelligent Auto-Selection

MCP Filesystem Ultra provides intelligent tools that automatically detect file size and choose the best strategy:

File Size	Strategy Used	What Happens
Small (less than 100KB)	Direct I/O	Fast, simple, single operation
Medium (100KB - 500KB)	Buffered I/O	Chunked processing, no timeout
Large (500KB - 5MB)	Streaming	Progressive read/write with progress
Very Large (more than 5MB)	Chunked Streaming	Multiple passes, memory-safe

You don’t need to know the file size or choose a strategy. The intelligent tools handle it automatically.

The Consolidated Tools (v4)

In v4, all intelligent tools have been consolidated into the core tools. The auto-selection behavior is now built-in.

`read_file`

What it does: Reads a file using the optimal strategy for its size. Supports partial reads with start_line/end_line.

When to use: Any time you need to read a file, regardless of its size.

Example:

read_file({path: "large_log.txt"})

Behind the scenes:

Small file? Uses direct read (fast)
Large file? Uses chunked read (no timeout)
Returns content either way

`write_file`

What it does: Writes content to a file using the optimal strategy.

When to use: Creating or overwriting files, especially when content might be large.

Example:

write_file({
  path: "output.json",
  content: largeJsonData
})

Behind the scenes:

Small content? Direct write
Large content? Streaming write with progress tracking
Creates backup before overwriting existing files

`edit_file`

What it does: Edits a file (search and replace) using the optimal strategy. Includes automatic error recovery and fuzzy matching.

When to use: Modifying existing files, regardless of file size.

Example:

edit_file({
  path: "config.go",
  old_text: "localhost:8080",
  new_text: "localhost:3000"
})

Behind the scenes:

Small file? Direct in-memory edit
Large file? Line-by-line streaming edit
Always creates backup before editing
Whitespace normalization and fuzzy matching (finds close matches)
Multiple retry strategies
95% success rate on previously failing edits

`analyze_operation`

What it does: Analyzes a file and provides optimization recommendations. Replaces the former get_optimization_suggestion and analyze_file tools.

When to use: Before performing an operation, to understand the best approach.

Example:

analyze_operation({path: "database.sql", operation: "file"})

Returns:

File Analysis: database.sql

Basic Info:
  Size: 2.3 MB
  Lines: 45,000
  Type: SQL
  Encoding: UTF-8

Size Category: Large
Recommended Strategy: Streaming I/O

Suggested Tools:
  Read: read_file or read_file with start_line/end_line
  Edit: edit_file
  Write: write_file

Warnings:
  - File has 45,000 lines - consider using read_file
    with start_line/end_line to read only the section you need

When to Use What

Use Core Tools (Recommended):

In v4, the core tools (read_file, write_file, edit_file) automatically detect file size and choose the best strategy. You do not need to pick a separate tool based on file size.

Use read_file for any file, any size
Use write_file for creating or overwriting files
Use edit_file for surgical text replacement
Use read_file with start_line/end_line for reading specific sections of large files

v4 Consolidated Tools vs v3 Separate Tools

Scenario	v3 (Separate Tools)	v4 (Consolidated)
Read 10KB file	`read_file`	`read_file` - same
Read 500KB file	`intelligent_read`	`read_file` - auto-streams
Read 5MB file	`intelligent_read`	`read_file` - auto-chunks
Edit with exact match	`edit_file`	`edit_file` - same
Edit with whitespace diff	`recovery_edit`	`edit_file` - built-in recovery

Performance Results

Before intelligent tools:

File Size	Success Rate	Time
50KB	80%	5-10s
100KB	30%	Often timeout
500KB	5%	Almost always timeout
1MB+	0%	Always timeout

After intelligent tools:

File Size	Success Rate	Time
50KB	100%	1-2s
100KB	100%	3-5s
500KB	100%	8-12s
1MB+	98%	15-30s

Overall improvement: 10% success rate to 98% success rate

Quick Reference

I want to…	Use this tool
Read any file safely	`read_file`
Read specific lines	`read_file` with `start_line`/`end_line`
Write any content safely	`write_file`
Edit any file safely	`edit_file`
Understand a file first	`analyze_operation` with `operation:"file"`

Summary

Why intelligent tools exist: Claude Desktop times out on large files.

What they do: The v4 core tools (read_file, write_file, edit_file) automatically select the right strategy based on file size.

When to use them: Always. The auto-selection is built into the core tools.

Result: 98% success rate instead of 10%.

Next Steps

Tool Selection Guide - Complete decision guide
Streaming Tools - For explicit large file control
Performance - Token optimization