Local MCP Integration Free

SnapBack integrates with AI coding assistants through the Model Context Protocol (MCP), enabling seamless context sharing while working entirely offline. The local MCP integration is available on all tiers and requires no cloud connectivity.

Privacy Guarantee

Available MCP Tools

The local MCP server provides the following tools to AI assistants:

1. create_snapshot

Create a snapshot of your current workspace state.

Parameters:

Copy{
  workspacePath: string;
  message?: string;
  tags?: string[];
}

Usage Example:

Copy// AI assistant can invoke this to create a snapshot before making changes
await mcp.call('create_snapshot', {
  workspacePath: '/Users/dev/my-project',
  message: 'Before refactoring authentication',
  tags: ['refactor', 'auth']
});

2. analyze_risk

Analyze files for security risks using SnapBack’s Guardian policy engine.

Parameters:

Copy{
  filePaths: string[];
  workspacePath: string;
}

Returns:

Copy{
  findings: Array<{
    file: string;
    type: 'secret' | 'mock_leakage' | 'phantom_dependency';
    severity: 'low' | 'medium' | 'high' | 'critical';
    line: number;
    message: string;
  }>;
  riskScore: number; // 0-10
}

Usage Example:

Copy// AI assistant checks for risks before suggesting code
const result = await mcp.call('analyze_risk', {
  filePaths: ['src/config.ts', 'src/auth.ts'],
  workspacePath: '/Users/dev/my-project'
});

3. check_deps

Check for phantom dependencies and missing imports.

Parameters:

Copy{
  workspacePath: string;
  packageManager?: 'npm' | 'yarn' | 'pnpm';
}

Returns:

Copy{
  phantomDeps: string[];
  missingDeps: string[];
  warnings: string[];
}

Supported AI Assistants

Claude Code (Cursor)

Cursor’s integration with Claude can leverage SnapBack’s local MCP server:

Copy// ~/.cursor/mcp-config.json
{
  "mcpServers": {
    "snapback": {
      "command": "snapback",
      "args": ["mcp", "start"],
      "type": "stdio"
    }
  }
}

GitHub Copilot

GitHub Copilot can use SnapBack’s MCP context for risk-aware suggestions:

Copy// VS Code settings.json
{
  "github.copilot.advanced": {
    "mcpServers": ["snapback"]
  }
}

Cline (formerly Claude Dev)

Configure Cline to use SnapBack’s local MCP:

Copy// Cline settings
{
  "mcp.servers": {
    "snapback": {
      "command": "snapback mcp start"
    }
  }
}

Configuration

Enabling Local MCP

Local MCP is enabled by default. To configure settings:

Copy// .snapbackconfig
{
  "mcp": {
    "local": {
      "enabled": true,
      "port": 3333, // Optional: custom port
      "autoStart": true // Start MCP server when extension activates
    }
  }
}

VS Code Extension Settings

Copy// VS Code settings.json
{
  "snapback.mcp.local.enabled": true,
  "snapback.mcp.local.autoStart": true,
  "snapback.mcp.local.logLevel": "info" // debug | info | warn | error
}

How It Works

The local MCP server operates entirely on your machine:

1. Startup: SnapBack extension starts a local MCP server on localhost:3333
2. Connection: AI assistants connect to the local server via stdio or HTTP
3. Tool Invocation: Assistants call MCP tools to interact with SnapBack
4. Response: SnapBack processes requests locally and returns results
5. No Network: All operations happen offline—no external requests

Context Shared Locally

The local MCP integration provides AI assistants with:

Protection Levels

File protection metadata to avoid risky modifications:

Copy{
  "protectionLevels": {
    "src/config.ts": "warn",
    "src/.env": "block",
    "src/secrets.json": "block"
  }
}

Session Context

Current session information for better assistance:

Copy{
  "currentSession": {
    "id": "session_12345",
    "name": "Implement authentication",
    "duration": 2400, // seconds
    "filesModified": ["src/auth.ts", "src/config.ts"],
    "snapshotCount": 3
  }
}

Risk Analysis Results

Recent security findings to avoid introducing similar risks:

Copy{
  "recentFindings": [
    {
      "type": "secret",
      "file": "src/config.ts",
      "severity": "high",
      "resolved": true,
      "timestamp": "2024-01-15T10:30:00Z"
    }
  ]
}

Privacy and Security

What Stays on Your Machine

• Everything: All data, snapshots, and analysis results remain local
• File contents and code
• Protection levels and policies
• Session metadata
• Risk analysis findings
• Configuration settings

What’s Never Shared

Local MCP integration never sends data externally:

• ❌ No file contents to cloud
• ❌ No code snippets to servers
• ❌ No personal information transmitted
• ❌ No usage telemetry (unless you opt-in separately)

Troubleshooting

MCP Server Not Starting

Copy# Check if MCP server is running
snapback mcp status

# Start MCP server manually
snapback mcp start

# Check logs for errors
snapback mcp logs

AI Assistant Can’t Connect

1. Verify MCP server is running: snapback mcp status
2. Check port configuration (default: 3333)
3. Restart your AI assistant
4. Enable debug logging: snapback --log-level debug mcp start

Performance Issues

If MCP operations are slow:

1. Reduce snapshot retention to free up disk space
2. Exclude large files from risk analysis via .snapbackignore
3. Disable auto-snapshots during heavy AI assistance sessions

CLI Commands

Copy# Start local MCP server
snapback mcp start

# Check MCP server status
snapback mcp status

# Stop MCP server
snapback mcp stop

# View MCP logs
snapback mcp logs [--tail 100]

# Test MCP connection
snapback mcp test

# Show shared context (for debugging)
snapback mcp context --format json

Best Practices

Upgrade to Backend MCP

Want cloud-powered features like advanced AI scoring and team collaboration?

Backend MCP (available on Solo, Team, and Enterprise plans) adds:

• ✓ Cloud-based Guardian AI risk scoring
• ✓ Team snapshot sharing
• ✓ Cloud backup and restore
• ✓ API access with authentication

Learn about Backend MCP →

Related Documentation

• Protection Levels - Configure file protection
• AI Detection - Understand risk analysis
• Session Time-Travel - Navigate your coding history
• CLI Reference - Command-line tools