Skip to main content

Context Management

Understanding context in MCP​

This guide explains how context management works in the Model Context Protocol:

  • Context fundamentals - Understand why context is crucial for meaningful AI conversations
  • MCP strategies - Learn the different approaches to managing conversation context efficiently
  • Implementation options - Explore how to configure context management in your MCP server
  • Best practices - Discover techniques for optimizing context for performance and security

Introduction​

Context management is one of the core features of the Model Context Protocol. It enables AI models to maintain awareness of previous interactions within a conversation, leading to more natural and effective communication.

Why Context Matters​

Without context management, AI models would treat each message as isolated, requiring users to repeat information and resulting in disjointed conversations. Good context management enables:

  • Coherent conversations - The model remembers previous messages and can refer back to them
  • Personalized responses - The model builds understanding of user preferences over time
  • Knowledge accumulation - Information shared earlier can be referenced in later messages
  • Seamless experiences - Users don't need to repeat themselves

How Context Management Works in MCP​

The MCP architecture handles context management automatically through several key components and processes:

Context Storage​

Each conversation is assigned a unique contextId. The MCP server uses this ID to:

  1. Store conversation history in a persistent database
  2. Retrieve relevant context when new messages arrive
  3. Update context with new interactions

Context Windows​

AI models have limits on how much context they can process at once, often measured in tokens. MCP handles this limitation by:

  1. Tracking token usage throughout the conversation
  2. Managing context windows by selecting which parts of the conversation to include
  3. Implementing smart truncation strategies when approaching token limits

Context Management Strategies​

Available Strategies​

MCP implements several strategies for effective context management:

  • Full History - Maintains complete conversation history (best for short conversations)
  • Sliding Window - Keeps only a fixed number of recent messages
  • Smart Truncation - Uses importance scoring to determine which messages to keep
  • Summary Strategy - Periodically generates summaries of older context

1. Full History Strategy​

The simplest approach is to maintain the complete conversation history. This works well for short conversations but can hit token limits for longer ones.

// Example of managing a conversation with full history
const conversation = client.createConversation({
  contextId: 'user-123',
  strategy: 'full-history',
});

await conversation.sendMessage("Hello!");
await conversation.sendMessage("What's the weather like today?");
// Both messages and responses are included in context

2. Sliding Window Strategy​

This approach keeps only a fixed number of recent messages:

// Example with sliding window (last 10 messages)
const conversation = client.createConversation({
  contextId: 'user-123',
  strategy: 'sliding-window',
  windowSize: 10, // Keep last 10 messages
});

3. Smart Truncation​

This advanced strategy uses importance scoring to determine which messages to keep:

// Example with smart truncation
const conversation = client.createConversation({
  contextId: 'user-123',
  strategy: 'smart-truncation',
  maxTokens: 4000, // Max tokens to send to model
});

4. Summary Strategy​

This approach periodically generates summaries of older context:

// Example with summary strategy
const conversation = client.createConversation({
  contextId: 'user-123',
  strategy: 'summary',
  summarizeThreshold: 20, // Summarize after 20 messages
});

Managing Context in Your MCP Server​

Implementation Guide​

Follow these steps to implement context management in your MCP server:

  1. Choose a context store - Select the appropriate storage option for your needs
  2. Configure context settings - Set up your preferred strategy and parameters
  3. Initialize the MCP server - Connect your context store to your server
  4. Test context persistence - Verify context is properly maintained across messages

Basic Context Setup​

When building an MCP server, configure context management in your server setup:

// src/index.js
import { MCPServer } from '@trmx/server';
import { MongoContextStore } from '@trmx/context-mongodb';

// Create a context store
const contextStore = new MongoContextStore({
  uri: process.env.MONGODB_URI,
  database: 'mcp',
  collection: 'contexts',
});

// Create MCP server with context store
const server = new MCPServer({
  port: 3000,
  contextStore,
  // Default context management settings
  contextSettings: {
    strategy: 'smart-truncation',
    maxTokens: 4000,
    summarizeThreshold: 15,
  },
});

server.start().then(() => {
  console.log('MCP server running on port 3000');
});

Advanced Context Configuration​

For more advanced scenarios, you can customize context management:

// src/context-manager.js
import { ContextManager } from '@trmx/server';

export class CustomContextManager extends ContextManager {
  async prepareContext(contextId, newMessage) {
    // Get existing context
    const context = await this.store.getContext(contextId);
    
    // Apply custom logic for context preparation
    if (context.messages.length > 20) {
      // Create a summary of older messages
      const oldMessages = context.messages.slice(0, 10);
      const summary = await this.createSummary(oldMessages);
      
      // Replace older messages with summary
      context.messages = [
        { role: 'system', content: `Conversation summary: ${summary}` },
        ...context.messages.slice(10)
      ];
    }
    
    // Add the new message
    context.messages.push(newMessage);
    
    // Save updated context
    await this.store.updateContext(contextId, context);
    
    return context;
  }
  
  async createSummary(messages) {
    // Custom logic to create a summary of messages
    // This might call an AI model to generate a summary
    return "Summary of previous conversation...";
  }
}

// Use custom context manager in server setup
const server = new MCPServer({
  contextManager: new CustomContextManager({
    store: contextStore,
  }),
});

Context Persistence​

Storage Options​

MCP supports different storage options for context persistence:

  • In-Memory Storage - Simple storage for development environments
  • MongoDB Storage - Scalable, persistent storage for production
  • Redis Storage - For high-throughput applications

In-Memory Storage (Development)​

Simple storage for development environments:

import { InMemoryContextStore } from '@trmx/server';

const contextStore = new InMemoryContextStore();

MongoDB Storage (Production)​

Scalable, persistent storage for production:

import { MongoContextStore } from '@trmx/context-mongodb';

const contextStore = new MongoContextStore({
  uri: process.env.MONGODB_URI,
  database: 'mcp',
  collection: 'contexts',
});

Redis Storage (High Performance)​

For high-throughput applications:

import { RedisContextStore } from '@trmx/context-redis';

const contextStore = new RedisContextStore({
  host: process.env.REDIS_HOST,
  port: process.env.REDIS_PORT,
  password: process.env.REDIS_PASSWORD,
});

Context Security​

Security Considerations​

When implementing context management, pay special attention to:

  • Context Isolation - Ensure contexts are properly isolated between different users
  • Data Protection - Implement encryption for sensitive conversation data
  • Access Control - Verify user ownership before allowing access to context
  • Data Lifecycle - Implement policies for context expiration and deletion

Context Isolation​

Ensure contexts are properly isolated between different users:

// Always include userId in contextId
const contextId = `user-${userId}-conversation-${conversationId}`;

// Use authentication middleware to verify ownership
function verifyContextOwnership(req, res, next) {
  const { contextId } = req.params;
  const userId = req.user.id;
  
  // Extract userId from contextId
  const [prefix, contextUserId] = contextId.split('-');
  
  if (prefix !== 'user' || contextUserId !== userId) {
    return res.status(403).json({ error: 'Unauthorized access to context' });
  }
  
  next();
}

// Use middleware in routes
app.get('/api/conversations/:contextId', verifyContextOwnership, (req, res) => {
  // Handle request
});

Performance Considerations​

Optimizing Context Management​

Consider these factors when configuring context management:

  • Token usage - More context means higher API costs with AI providers
  • Response time - Large contexts increase processing time
  • Memory consumption - Context storage requires server memory and database space
  • Relevance - Not all historical messages are equally important

Balancing these factors requires careful configuration:

// Balanced configuration example
const conversation = client.createConversation({
  contextId: 'user-123',
  strategy: 'smart-truncation',
  maxTokens: 3000,
  relevanceThreshold: 0.7, // Keep messages with relevance score above 0.7
  keepSystemMessages: true, // Always retain system messages
});

Security and Privacy​

When implementing context management, consider these security aspects:

  1. Data encryption - Encrypt sensitive conversation data at rest
  2. Context isolation - Ensure contexts are strictly separated between users
  3. Data retention - Implement appropriate retention policies
  4. User control - Allow users to clear their conversation history

Next Steps​

Continue Learning​

Now that you understand context management, explore these related topics: