Add an MCP Server to Your Flutter/Dart Tooling

dart create -t package mcp_flutter_server
cd mcp_flutter_server

# pubspec.yaml
dependencies:
  mcp_dart: ^0.3.0
  path: ^1.8.0

import 'package:mcp_dart/mcp_dart.dart';
import 'dart:io';
import 'dart:convert';
import 'package:path/path.dart' as path;

void main() async {
  final server = McpServer(
    name: 'flutter-mcp-server',
    version: '1.0.0',
  );

  // Tool: List Flutter project structure
  server.addTool(
    name: 'getProjectStructure',
    description: 'Get the structure of a Flutter project',
    inputSchema: ToolInputSchema(
      type: 'object',
      properties: {
        'projectPath': {
          'type': 'string',
          'description': 'Path to the Flutter project',
        },
      },
      required: ['projectPath'],
    ),
    callback: (args, extra) async {
      final projectPath = args['projectPath'] as String;
      final structure = <String, dynamic>{};

      // Read pubspec.yaml
      final pubspecFile = File(path.join(projectPath, 'pubspec.yaml'));
      if (await pubspecFile.exists()) {
        structure['pubspec'] = await pubspecFile.readAsString();
      }

      // List lib directory
      final libDir = Directory(path.join(projectPath, 'lib'));
      if (await libDir.exists()) {
        final files = <String>[];
        await for (final entity in libDir.list(recursive: true)) {
          if (entity is File) {
            files.add(path.relative(entity.path, from: projectPath));
          }
        }
        structure['libFiles'] = files;
      }

      return CallToolResult(
        content: [TextContent(text: jsonEncode(structure))],
      );
    },
  );

  // Tool: Run Flutter analyze
  server.addTool(
    name: 'runFlutterAnalyze',
    description: 'Run flutter analyze on a project',
    inputSchema: ToolInputSchema(
      type: 'object',
      properties: {
        'projectPath': {
          'type': 'string',
          'description': 'Path to the Flutter project',
        },
      },
      required: ['projectPath'],
    ),
    callback: (args, extra) async {
      final projectPath = args['projectPath'] as String;
      final result = await Process.run(
        'flutter',
        ['analyze'],
        workingDirectory: projectPath,
        runInShell: true,
      );

      return CallToolResult(
        content: [
          TextContent(text: 'Exit code: ${result.exitCode}'),
          TextContent(text: result.stdout.toString()),
          if (result.stderr.isNotEmpty) TextContent(text: result.stderr.toString()),
        ],
        isError: result.exitCode != 0,
      );
    },
  );

  // Tool: Run Dart tests
  server.addTool(
    name: 'runDartTest',
    description: 'Run dart test on a specific test file',
    inputSchema: ToolInputSchema(
      type: 'object',
      properties: {
        'projectPath': {'type': 'string'},
        'testFile': {'type': 'string'},
      },
      required: ['projectPath', 'testFile'],
    ),
    callback: (args, extra) async {
      final projectPath = args['projectPath'] as String;
      final testFile = args['testFile'] as String;
      
      final result = await Process.run(
        'dart',
        ['test', testFile],
        workingDirectory: projectPath,
      );

      return CallToolResult(
        content: [
          TextContent(text: result.stdout.toString()),
          if (result.stderr.isNotEmpty) TextContent(text: result.stderr.toString()),
        ],
        isError: result.exitCode != 0,
      );
    },
  );

  // Start the server
  await server.start();
}

{
  "mcpServers": {
    "flutter-dart": {
      "command": "dart",
      "args": ["/absolute/path/to/mcp_flutter_server/bin/mcp_server.dart"],
      "description": "Flutter/Dart MCP server for Claude Code"
    }
  }
}

cd /path/to/your/flutter/project
claude-code

Use the MCP server to analyze my Flutter project structure and tell me:
1. What dependencies I have
2. What files exist in lib/
3. Any analyzer errors

server.addTool(
  name: 'generateBloc',
  description: 'Generate BLoC pattern files for a feature',
  inputSchema: ToolInputSchema(
    type: 'object',
    properties: {
      'featureName': {'type': 'string'},
      'projectPath': {'type': 'string'},
    },
    required: ['featureName', 'projectPath'],
  ),
  callback: (args, extra) async {
    final featureName = args['featureName'] as String;
    final projectPath = args['projectPath'] as String;
    final featurePath = path.join(projectPath, 'lib', 'features', featureName);

    // Create directories
    await Directory(path.join(featurePath, 'bloc')).create(recursive: true);
    await Directory(path.join(featurePath, 'ui')).create(recursive: true);

    // Generate BLoC file
    final blocFile = File(path.join(featurePath, 'bloc', '${featureName}_bloc.dart'));
    await blocFile.writeAsString('''
import 'package:flutter_bloc/flutter_bloc.dart';

abstract class ${featureName}Event {}
abstract class ${featureName}State {}

class ${featureName}Bloc extends Bloc<${featureName}Event, ${featureName}State> {
  ${featureName}Bloc() : super(${featureName}Initial()) {
    on<${featureName}Event>((event, emit) {
      // TODO: implement
    });
  }
}
''');

    return CallToolResult(
      content: [TextContent(text: 'Generated BLoC for $featureName')],
    );
  },
);

Ask Claude: "Explain the BLoC pattern used in the auth feature"

Ask Claude: "Run flutter analyze and fix any issues"

Ask Claude: "Generate API documentation for the UserRepository class"

dart /path/to/mcp_server.dart 2>&1

cat ~/.claude-code/mcp_config.json