Diving into MCP Advanced Server Capabilities: A Comprehensive Guide

// CLIENT SIDE - Request with progress tracking
const response = await client.request("tools/analyze", {
  path: "/my/project",
  _meta: { progressToken: "abc123" }
});

// Listen for progress updates
client.on("notifications/progress", (update) => {
  console.log(`${update.progress}% - ${update.message}`);
  // Update progress bar here
});

// SERVER SIDE - Send progress updates
async function analyzeFiles(path, progressToken) {
  const files = await getFiles(path);
  
  for (let i = 0; i < files.length; i++) {
    await analyzeFile(files[i]);
    
    // Send progress update
    if (progressToken) {
      await server.notify("notifications/progress", {
        progressToken,
        progress: i + 1,
        total: files.length,
        message: `Analyzing ${files[i]}`
      });
    }
  }
  
  return results;
}

// CLIENT SIDE - Send cancellation
async function cancelOperation(requestId) {
  await client.notify("notifications/cancelled", {
    requestId,
    reason: "User cancelled"
  });
}

// Start operation and store request ID
const requestId = "migration-123";
const response = client.request("tools/migrate", {
  data: myData,
  _meta: { requestId }
});

// Cancel if needed
await cancelOperation(requestId);

// SERVER SIDE - Handle cancellation
const operations = new Map();

async function migrateData(data, requestId) {
  operations.set(requestId, { cancelled: false });
  
  for (const item of data) {
    // Check if cancelled
    if (operations.get(requestId)?.cancelled) {
      return { status: "cancelled" };
    }
    
    await processItem(item);
  }
  
  operations.delete(requestId);
  return { status: "completed" };
}

// Listen for cancellations
server.on("notifications/cancelled", ({ requestId }) => {
  const op = operations.get(requestId);
  if (op) op.cancelled = true;
});

// SERVER SIDE - Handle ping requests
server.onRequest("ping", () => {
  return {}; // Just return empty object
});

// CLIENT SIDE - Check connection health
async function checkConnection() {
  try {
    await client.request("ping");
    updateStatus("🟢 Connected");
  } catch (error) {
    updateStatus("🔴 Disconnected");
  }
}

function updateStatus(message) {
  document.getElementById('status').textContent = message;
}

// Check every 30 seconds
setInterval(checkConnection, 30000);

// CLIENT SIDE - Request completions
async function getCompletions(partial) {
  const result = await client.request("completion/complete", {
    ref: { type: "ref/prompt", name: "open_file" },
    argument: { name: "filePath", value: partial }
  });
  
  return result.completion.values;
}

// Show suggestions as user types
input.oninput = async (e) => {
  const suggestions = await getCompletions(e.target.value);
  showDropdown(suggestions);
};

// SERVER SIDE - Provide completions
server.onRequest("completion/complete", ({ argument }) => {
  if (argument.name === "filePath") {
    const files = getMatchingFiles(argument.value);
    return { completion: { values: files } };
  }
  
  return { completion: { values: [] } };
});

function getMatchingFiles(partial) {
  return allFiles
    .filter(file => file.startsWith(partial))
    .slice(0, 10);
}

// CLIENT SIDE - Set log level and listen
await client.request("logging/setLevel", { level: "debug" });

client.on("notifications/message", ({ level, logger, message }) => {
  console.log(`[${level}] ${logger}: ${message}`);
  // Show in UI log console
});

// SERVER SIDE - Send log messages
function log(level, component, message, data) {
  server.notify("notifications/message", {
    level,
    logger: component,
    message,
    data: sanitize(data)
  });
}

function sanitize(data) {
  if (!data) return;
  const clean = { ...data };
  ['password', 'token', 'key'].forEach(key => {
    if (clean[key]) clean[key] = "[REDACTED]";
  });
  return clean;
}

// Use in your code
async function processPayment(data) {
  log("info", "Payment", "Processing payment");
  
  try {
    const result = await callAPI(data);
    log("info", "Payment", "Payment successful");
    return result;
  } catch (error) {
    log("error", "Payment", "Payment failed", { error });
    throw error;
  }
}

// CLIENT SIDE - Request paginated results
let currentCursor = null;

async function searchTodos(query, cursor = null) {
  const response = await client.request("tools/searchTodos", {
    query,
    cursor
  });
  
  currentCursor = response.nextCursor;
  return response;
}

// Start new search
async function startSearch(query) {
  currentCursor = null;
  const results = await searchTodos(query);
  showResults(results.items);
  return results;
}

// Load more results
async function loadMore(query) {
  if (!currentCursor) return;
  
  const results = await searchTodos(query, currentCursor);
  appendResults(results.items);
  return results;
}

function showResults(items) {
  console.log("Search results:");
  items.forEach(item => {
    console.log(`${item.number}. ${item.file}:${item.line} - ${item.text}`);
  });
}

// SERVER SIDE - How to handle pagination
async function searchTodos(query, cursor) {
  const pageSize = 20;
  const allResults = await findAllTodos(); // Get all TODOs
  
  // Parse cursor to get current position
  const start = cursor ? parseInt(cursor) : 0;
  const end = start + pageSize;
  
  // Get page of results
  const pageResults = allResults.slice(start, end);
  const hasMore = end < allResults.length;
  
  return {
    results: pageResults.map((todo, i) => ({
      number: start + i + 1,
      file: todo.file,
      line: todo.line,
      text: todo.text
    })),
    nextCursor: hasMore ? end.toString() : null,
    total: allResults.length,
    showing: `${start + 1}-${Math.min(end, allResults.length)}`
  };
}

// Handle paginated requests
server.on("tools/searchTodos", async ({ query, cursor }) => {
  const results = await searchTodos(query, cursor);
  
  return {
    items: results.results,
    nextCursor: results.nextCursor,
    summary: `Showing ${results.showing} of ${results.total} results`
  };
});

// CLIENT SIDE - Provide roots to server
let allowedRoots = [
  "/Users/you/project",
  "/Users/you/documents/work"
];

// Handle server requests for allowed roots
client.onRequest("roots/list", () => {
  return { roots: allowedRoots.map(dir => ({ uri: dir })) };
});

// Add new directory
function addAllowedDirectory(directory) {
  if (!allowedRoots.includes(directory)) {
    allowedRoots.push(directory);
    console.log(`Added access to: ${directory}`);
  }
}

// SERVER SIDE - Check file access safely
let allowedDirectories = [];

async function loadAllowedRoots(client) {
  if (client.capabilities?.roots) {
    const { roots } = await client.request("roots/list");
    allowedDirectories = roots.map(r => r.uri);
    console.log("Allowed directories:", allowedDirectories);
  }
}

function isFileAllowed(filePath) {
  return allowedDirectories.some(root => 
    filePath.startsWith(root)
  );
}

async function safeReadFile(filePath) {
  if (!isFileAllowed(filePath)) {
    throw new Error(`Access denied: ${filePath}`);
  }
  return fs.readFile(filePath, 'utf-8');
}

async function safeDeleteFile(filePath) {
  if (!isFileAllowed(filePath)) {
    throw new Error(`Access denied: ${filePath}`);
  }
  return fs.unlink(filePath);
}

// Usage
server.on("tools/cleanTemp", async () => {
  const tempFiles = await fs.readdir('./tmp');
  let deleted = 0;
  
  for (const file of tempFiles) {
    if (file.endsWith('.tmp')) {
      await safeDeleteFile(`./tmp/${file}`);
      deleted++;
    }
  }
  
  return { message: `Deleted ${deleted} temporary files` };
});

// Ask AI to generate content
async function generateCommitMessage(changes) {
  // Check if client supports sampling
  if (!client.capabilities?.sampling) {
    return "Updated files"; // Fallback
  }
  
  // Ask AI to generate commit message
  const prompt = `Generate a commit message for these changes:
${changes.map(c => `- ${c}`).join('\n')}

Use conventional commit format (feat/fix/docs/etc).`;
  
  const response = await client.request("sampling/createMessage", {
    messages: [{
      role: "user",
      content: { type: "text", text: prompt }
    }],
    maxTokens: 100
  });
  
  return response.content.text;
}

// Usage example
server.on("tools/commit", async () => {
  // Get changed files
  const changes = await getGitChanges();
  
  // Generate commit message
  const message = await generateCommitMessage(changes);
  
  // Show to user for approval
  return {
    message,
    changes,
    action: "Please review the commit message"
  };
});

// CLIENT SIDE - Subscribe to resource changes
async function watchResource(path) {
  await client.request("resources/subscribe", { uri: path });
  console.log(`Watching ${path}`);
}

// Listen for resource updates
client.on("notifications/resources/updated", ({ updates }) => {
  updates.forEach(update => {
    console.log(`${update.uri} changed`);
    refreshContent(update.uri);
  });
});

// Unsubscribe when done
async function stopWatching(path) {
  await client.request("resources/unsubscribe", { uri: path });
}

// SERVER SIDE - Handle subscriptions
const watchers = new Map();

server.onRequest("resources/subscribe", ({ uri }) => {
  const watcher = watchFile(uri, () => {
    // Send update notification
    server.notify("notifications/resources/updated", {
      updates: [{ 
        uri, 
        type: "changed", 
        timestamp: new Date().toISOString() 
      }]
    });
  });
  
  watchers.set(uri, watcher);
  return { success: true };
});

server.onRequest("resources/unsubscribe", ({ uri }) => {
  const watcher = watchers.get(uri);
  if (watcher) {
    watcher.close();
    watchers.delete(uri);
  }
  return { success: true };
});