Claude for Long Document Analysis — 200K Token Guide 2026

import anthropic
from pathlib import Path
 
client = anthropic.Anthropic()
 
def analyze_document(file_path: str, question: str) -> str:
    """Load and analyze a text document with Claude."""
    content = Path(file_path).read_text(encoding="utf-8")
 
    # Rough token estimate: 1 token ≈ 4 characters
    estimated_tokens = len(content) // 4
    print(f"Document size: ~{estimated_tokens:,} tokens")
 
    if estimated_tokens > 180_000:
        raise ValueError(
            f"Document too large (~{estimated_tokens:,} tokens). "
            "Use chunked analysis instead."
        )
 
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=4096,
        messages=[
            {
                "role": "user",
                "content": f"{content}\n\n---\n\nQuestion: {question}",
            }
        ],
    )
 
    return response.content[0].text
 
# Analyze a 200-page legal contract
result = analyze_document(
    "service_agreement.txt",
    "Identify all termination clauses, their conditions, and the notice periods required."
)
print(result)

import anthropic
from pathlib import Path
 
client = anthropic.Anthropic()
 
EXCLUDE_PATTERNS = {".git", "__pycache__", "node_modules", ".venv", "dist", "build"}
INCLUDE_EXTENSIONS = {".py", ".js", ".ts", ".go", ".java", ".rs", ".sql", ".yaml", ".yml"}
 
def load_codebase(root_dir: str, max_tokens: int = 150_000) -> str:
    """Load source files from a directory into a formatted string."""
    root = Path(root_dir)
    sections = []
    total_chars = 0
    max_chars = max_tokens * 4  # Approximate: 4 chars per token
 
    for path in sorted(root.rglob("*")):
        # Skip excluded directories
        if any(excl in path.parts for excl in EXCLUDE_PATTERNS):
            continue
        if path.suffix not in INCLUDE_EXTENSIONS:
            continue
        if not path.is_file():
            continue
 
        try:
            content = path.read_text(encoding="utf-8")
        except Exception:
            continue
 
        relative = path.relative_to(root)
        section = f"=== {relative} ===\n{content}\n"
 
        if total_chars + len(section) > max_chars:
            sections.append(f"[Additional files truncated — {max_chars // 4000} file limit reached]")
            break
 
        sections.append(section)
        total_chars += len(section)
 
    return "\n".join(sections)
 
def review_codebase_security(root_dir: str) -> str:
    codebase = load_codebase(root_dir)
 
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=4096,
        messages=[
            {
                "role": "user",
                "content": (
                    f"{codebase}\n\n"
                    "---\n\n"
                    "Perform a comprehensive security audit of this codebase.\n\n"
                    "For each finding:\n"
                    "1. File and line reference\n"
                    "2. Vulnerability type (OWASP category if applicable)\n"
                    "3. Severity: Critical / High / Medium / Low\n"
                    "4. Corrected code\n\n"
                    "Prioritize: injection flaws, authentication issues, "
                    "exposed secrets, and insecure dependencies."
                ),
            }
        ],
    )
 
    return response.content[0].text

import anthropic
from typing import Iterator
 
client = anthropic.Anthropic()
 
def chunk_text(text: str, chunk_size: int = 100_000) -> Iterator[str]:
    """Split text into overlapping chunks."""
    overlap = 2_000  # Characters of overlap to preserve context across chunks
    start = 0
    while start < len(text):
        end = start + chunk_size
        yield text[start:end]
        start = end - overlap
 
def analyze_large_document(
    file_path: str,
    question: str,
    synthesis_model: str = "claude-3-5-sonnet-20241022",
) -> str:
    """Analyze a document too large for a single context window."""
    content = open(file_path).read()
 
    # Step 1: Analyze each chunk
    chunk_summaries = []
    for i, chunk in enumerate(chunk_text(content)):
        response = client.messages.create(
            model="claude-3-5-haiku-20241022",  # Use Haiku for cheaper chunk processing
            max_tokens=1024,
            messages=[
                {
                    "role": "user",
                    "content": (
                        f"Chunk {i + 1} of the document:\n\n{chunk}\n\n"
                        f"Extract information relevant to this question: {question}\n"
                        "Be concise — only include directly relevant findings."
                    ),
                }
            ],
        )
        chunk_summaries.append(f"Chunk {i + 1}:\n{response.content[0].text}")
        print(f"Processed chunk {i + 1}")
 
    # Step 2: Synthesize all chunk summaries into a final answer
    combined = "\n\n".join(chunk_summaries)
    final_response = client.messages.create(
        model=synthesis_model,
        max_tokens=4096,
        messages=[
            {
                "role": "user",
                "content": (
                    f"These are summaries from different sections of a document:\n\n"
                    f"{combined}\n\n"
                    f"Based on all sections, provide a comprehensive answer to: {question}"
                ),
            }
        ],
    )
 
    return final_response.content[0].text

def compare_documents(doc_paths: list[str], comparison_question: str) -> str:
    """Compare multiple documents within a single Claude context."""
    sections = []
    for i, path in enumerate(doc_paths):
        content = open(path).read()
        sections.append(f"=== Document {i + 1}: {path} ===\n{content}")
 
    combined = "\n\n".join(sections)
 
    response = client.messages.create(
        model="claude-3-5-sonnet-20241022",
        max_tokens=4096,
        messages=[
            {
                "role": "user",
                "content": f"{combined}\n\n---\n\n{comparison_question}",
            }
        ],
    )
    return response.content[0].text
 
# Example: compare two API contracts
result = compare_documents(
    ["v1_api_spec.md", "v2_api_spec.md"],
    "List all breaking changes between v1 and v2. "
    "For each: what changed, who is affected, and what migration is required."
)