Anthropic Claude MCP: Model Context Protocol Explained

Claude’s Model Context Protocol (MCP) is the secret sauce that lets developers treat Claude more like a collaborative teammate than a static endpoint. Instead of sending a single prompt and getting a single reply, MCP lets you orchestrate multi‑turn conversations, manage token budgets, and preserve context across sessions—all while staying within Claude’s strict token limits. In this post we’ll unpack the protocol, walk through real code, and share pro tips so you can squeeze the most out of Claude for long‑form writing, chatbots, and data‑heavy workflows.

What is Claude MCP?

At its core, MCP is a lightweight, JSON‑based contract that defines how you package messages, system instructions, and user inputs for Claude. Think of it as the “conversation envelope” that tells Claude what it knows, what it should do next, and how many tokens you’ve allocated for the round.

Claude’s underlying model has a fixed context window (e.g., 100k tokens for Claude‑3.5). If you exceed that window, older tokens get trimmed, potentially breaking the thread. MCP solves this by giving you explicit control over what stays, what gets rolled out, and how to request a “sliding window” that preserves the most relevant bits.

Core concepts of MCP

• Message roles: system, user, and assistant. Each role influences how Claude interprets the text.
• Token budget: You declare a maximum token count for the upcoming request. Claude will truncate or summarize to stay within it.
• Context window: The total tokens Claude can see at once. MCP lets you manage this window manually.
• Sliding context: A strategy where you keep the most recent N messages and optionally a summarized version of older ones.

Understanding these concepts is the first step toward building robust applications that never “lose the thread” mid‑conversation.

How the Model Context Protocol Works

When you call Claude via the API, you send a JSON payload that follows the MCP schema. The payload contains an array of messages, each with a role and content. In addition, you can include optional fields like max_tokens, temperature, and a metadata block for custom tracking.

Claude then processes the messages in order, respecting the token budget you set. If the combined token count of the messages exceeds the budget, Claude will either truncate older messages or request a summarization pass—depending on the truncation_strategy you specify.

Message schema

payload = {
    "model": "claude-3.5-sonnet",
    "max_tokens": 4096,
    "temperature": 0.7,
    "messages": [
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Explain the difference between lists and tuples in Python."},
        {"role": "assistant", "content": "Sure! Lists are mutable..."},
        # Additional turns go here
    ],
    "truncation_strategy": "sliding",  # or "truncate"
    "metadata": {"session_id": "abc123"}
}

The truncation_strategy field is where MCP shines. With "sliding", Claude will keep the most recent messages up to max_tokens and automatically summarize older content if needed. This keeps the conversation coherent without manual token bookkeeping.

Token budgeting and sliding windows

• Calculate the token count of each message using anthropic.Tokenizer.encode() (or a compatible tokenizer).
• Reserve a buffer (e.g., 10% of max_tokens) for Claude’s response.
• Apply the sliding strategy: keep newest messages intact, replace older ones with a concise summary.

Below is a practical Python helper that builds an MCP‑compatible payload while handling the sliding window automatically.

import json
from anthropic import Anthropic, Tokenizer

client = Anthropic(api_key="YOUR_API_KEY")
tokenizer = Tokenizer()

def build_mcp_payload(messages, max_tokens=4096, buffer_ratio=0.1):
    # Reserve space for Claude's reply
    reserve = int(max_tokens * buffer_ratio)
    available = max_tokens - reserve

    # Token count per message
    token_counts = [len(tokenizer.encode(m["content"])) for m in messages]

    # Slide window from the end until we fit within 'available'
    kept = []
    total = 0
    for msg, count in zip(reversed(messages), reversed(token_counts)):
        if total + count > available:
            break
        kept.insert(0, msg)  # prepend to maintain order
        total += count

    # If we dropped any messages, prepend a summary placeholder
    if len(kept) < len(messages):
        summary = "Summary of earlier conversation: " + summarize(messages[:-len(kept)])
        kept.insert(0, {"role": "assistant", "content": summary})

    payload = {
        "model": "claude-3.5-sonnet",
        "max_tokens": max_tokens,
        "temperature": 0.7,
        "messages": kept,
        "truncation_strategy": "sliding",
    }
    return payload

def summarize(old_messages):
    # Very naive summarizer – replace with a real call if needed
    topics = set()
    for m in old_messages:
        if m["role"] == "user":
            topics.add(m["content"].split()[0])
    return "We discussed: " + ", ".join(topics) + "."

# Example usage
history = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Explain recursion."},
    {"role": "assistant", "content": "Recursion is..."},
    {"role": "user", "content": "Give a Python example."},
    {"role": "assistant", "content": "Sure, here's a function..."},
    # Add many more turns as needed
]

payload = build_mcp_payload(history, max_tokens=4096)
response = client.messages.create(**payload)
print(response.content[0].text)

The helper automatically trims the conversation, adds a lightweight summary, and respects Claude’s token limits. You can swap the summarize function with a call to Claude itself for higher‑quality summaries.

Real‑World Use Cases

Now that we have the mechanics down, let’s explore where MCP truly shines. From drafting technical articles to building memory‑rich chatbots, MCP enables developers to maintain context without hitting hard token caps.

Long‑form content generation

• Outline first: Send a system message with a detailed outline.
• Chunked writing: Generate each section in a separate turn, feeding the previous section as context.
• Iterative refinement: Use a sliding window to keep the latest two sections while summarizing earlier ones.

Here’s a concise example that writes a 2,000‑word blog post about “MCP” in 5‑sentence chunks, preserving coherence via MCP.

def generate_blog_section(section_prompt, history):
    # Append the new request to the conversation
    history.append({"role": "user", "content": section_prompt})
    payload = build_mcp_payload(history, max_tokens=4096)
    response = client.messages.create(**payload)
    section_text = response.content[0].text
    history.append({"role": "assistant", "content": section_text})
    return section_text, history

# Initial outline (system message)
conversation = [
    {"role": "system", "content": "Write a detailed blog post about Claude MCP. Structure: intro, core concepts, protocol walk‑through, use cases, conclusion."}
]

outline_prompt = "Start with a 3‑sentence introduction."
intro, conversation = generate_blog_section(outline_prompt, conversation)

# Continue with subsequent sections...

By re‑using conversation across calls, you keep the narrative thread alive while never exceeding Claude’s context window.

Conversational agents with persistent memory

Customer‑support bots often need to remember a user’s preferences across dozens of messages. MCP makes it easy to store a “memory” object in the metadata field and inject it as a system message at the start of each turn.

def update_memory(metadata, new_fact):
    # Append a fact to the user's memory dictionary
    metadata.setdefault("facts", []).append(new_fact)
    return metadata

def chat_with_memory(user_input, metadata):
    # Build system message that reflects current memory
    memory_summary = "User facts: " + ", ".join(metadata.get("facts", []))
    system_msg = {"role": "system", "content": memory_summary}
    
    # Assemble payload
    payload = {
        "model": "claude-3.5-sonnet",
        "max_tokens": 2048,
        "temperature": 0.5,
        "messages": [system_msg, {"role": "user", "content": user_input}],
        "metadata": metadata,
        "truncation_strategy": "sliding"
    }
    response = client.messages.create(**payload)
    answer = response.content[0].text
    
    # Example: extract a new fact from the answer (naïve regex)
    if "I prefer" in answer:
        fact = answer.split("I prefer")[1].strip().split(".")[0]
        metadata = update_memory(metadata, f"prefers {fact}")
    
    return answer, metadata

# Session start
session_meta = {"session_id": "support-789"}
reply, session_meta = chat_with_memory("Hi, I need help with my order.", session_meta)
print(reply)

This pattern lets the bot “remember” preferences without persisting the entire conversation history, saving tokens and keeping responses snappy.

Pro Tips for Optimizing Claude MCP

Tip 1 – Use concise system prompts. System messages count toward the token budget but don’t generate output. Keep them under 50 tokens for maximum flexibility.

Tip 2 – Summarize aggressively. When you hit 80% of the context window, trigger a summarization pass. Claude’s summarize tool can produce a 1‑2‑sentence recap that preserves key facts.

Tip 3 – Cache embeddings. For retrieval‑augmented generation, store vector embeddings of earlier messages. When you need to re‑introduce older context, pull the most relevant snippets instead of the full text.

Tip 4 – Leverage metadata for state. Store IDs, timestamps, or user flags in metadata. Claude can read them but they don’t consume token budget.

Common Pitfalls and How to Avoid Them

1. Over‑loading the system prompt. A bloated system message eats tokens and can cause premature truncation. Keep it focused on role and high‑level instructions.
2. Ignoring token budgets. If you set max_tokens too low, Claude may cut off mid‑sentence. Reserve at least 10‑15% of the budget for the model’s reply.
3. Relying on naive truncation. Simple cut‑off can break code snippets or JSON. Use the sliding strategy with a summarizer to keep structural integrity.
4. Forgetting to update metadata. State that lives outside the message array (e.g., user IDs) should be refreshed each call, or you’ll lose continuity across sessions.

Conclusion

Claude’s Model Context Protocol transforms a static LLM into a dynamic partner capable of handling long‑form writing, memory‑rich chat, and token‑aware workflows. By mastering the message schema, token budgeting, and sliding windows, you can build applications that stay coherent, efficient, and scalable. The code snippets above give you a ready‑to‑run foundation—plug them into your own projects, experiment with summarization strategies, and watch Claude become a truly collaborative teammate.