Where to Use MCPs

import Anthropic from '@anthropic-ai/sdk';
import { MCPClient } from '@leanmcp/client';

const anthropic = new Anthropic();
const mcp = new MCPClient('http://your-mcp-server.com');

// Get tools from your MCP
const tools = await mcp.listTools();

async function runAgent(userMessage: string) {
  const messages = [{ role: 'user', content: userMessage }];
  
  // Agent loop
  while (true) {
    const response = await anthropic.messages.create({
      model: 'claude-sonnet-4-5-20250929',
      max_tokens: 1024,
      tools: tools,  // Your MCP tools
      messages
    });
    
    // Check for tool calls
    const toolCalls = response.content.filter(c => c.type === 'tool_use');
    
    if (toolCalls.length === 0) {
      // No more tool calls - return final response
      return response.content.find(c => c.type === 'text')?.text;
    }
    
    // Execute tool calls via MCP
    for (const call of toolCalls) {
      const result = await mcp.callTool(call.name, call.input);
      messages.push({
        role: 'tool',
        tool_use_id: call.id,
        content: JSON.stringify(result)
      });
    }
  }
}

@Prompt({ description: "Prompt A - Concise responses" })
promptA() {
  return {
    messages: [{
      role: "user",
      content: { type: "text", text: "Be concise. One sentence answers." }
    }]
  };
}

@Prompt({ description: "Prompt B - Detailed explanations" })
promptB() {
  return {
    messages: [{
      role: "user",
      content: { type: "text", text: "Provide detailed explanations with examples." }
    }]
  };
}

@Prompt({ description: "Prompt C - Step by step" })
promptC() {
  return {
    messages: [{
      role: "user",
      content: { type: "text", text: "Break down responses into numbered steps." }
    }]
  };
}

import { AuthProvider, Authenticated } from "@leanmcp/auth";

// Connect to your internal SSO
const authProvider = new AuthProvider('custom', {
  jwksUri: 'https://your-sso.company.com/.well-known/jwks.json',
  issuer: 'https://your-sso.company.com',
  audience: 'internal-mcp'
});

await authProvider.init();

@Authenticated(authProvider)
export class InternalDataService {
  
  @Tool({ description: "Get team data" })
  async getTeamData(input: { dataType: string }) {
    // authUser contains SSO claims including groups/scopes
    const userTeam = authUser['groups']?.[0];
    const allowedScopes = authUser['scopes'] || [];
    
    // Check if user has access to requested data
    if (!allowedScopes.includes(`read:${input.dataType}`)) {
      return { error: "Access denied", requiredScope: `read:${input.dataType}` };
    }
    
    // Fetch data based on team membership
    return await internalDb.getData({
      team: userTeam,
      type: input.dataType,
      requestedBy: authUser.sub  // Audit trail
    });
  }
}