Flutter MCP #

🙌 Support This Project #

If you find this package useful, consider supporting ongoing development on Patreon.

🔗 MCP Dart Package Family #

mcp_server: Exposes tools, resources, and prompts to LLMs. Acts as the AI server.
mcp_client: Connects Flutter/Dart apps to MCP servers. Acts as the client interface.
mcp_llm: Bridges LLMs (Claude, OpenAI, etc.) to MCP clients/servers. Acts as the LLM brain.
flutter_mcp: Complete Flutter plugin for MCP integration with platform features.
flutter_mcp_ui_core: Core models, constants, and utilities for Flutter MCP UI system.
flutter_mcp_ui_runtime: Comprehensive runtime for building dynamic, reactive UIs through JSON specifications.
flutter_mcp_ui_generator: JSON generation toolkit for creating UI definitions with templates and fluent API.

A Flutter plugin for integrating Large Language Models (LLMs) with Model Context Protocol (MCP). This plugin provides comprehensive integration between MCP components and platform-specific features like background execution, notifications, system tray, and lifecycle management.

Features #

MCP Integration:
- Built-in MCP client, server, and LLM capabilities (no need for separate packages)
- Support for multiple simultaneous MCP clients and servers
- LLM integration with MCP components
- Enhanced batch processing with priority-based deduplication
Platform Features:
- Background service execution with task queuing
- Local notifications with enhanced configuration
- System tray support with dynamic menu management (desktop platforms)
- Application lifecycle management with health monitoring
- Secure storage for credentials and configuration
Advanced Capabilities:
- Real-time Health Monitoring: Component-level health tracking with event-driven updates
- Enhanced Error Handling: Circuit breaker pattern with automatic recovery strategies
- Resource Management: Automatic cleanup with leak detection and memory optimization
- Performance Monitoring: Advanced metrics with aggregation, anomaly detection, and threshold alerts
- Plugin System: Version management, sandboxing, and dependency resolution
- Security Features: Comprehensive audit logging, encryption management, and risk assessment
- Type Safety: Typed platform channels eliminating manual JSON handling
- Dynamic Configuration: Runtime config updates with validation and rollback support
- Cross-platform support: Android, iOS, macOS, Windows, Linux, Web

Getting Started #

Installation #

Add the package to your pubspec.yaml:

dependencies:
  flutter_mcp: ^1.0.3

Or install via command line:

flutter pub add flutter_mcp

Platform Setup (Optional) #

Android Configuration

You can configure Android-specific settings in your pubspec.yaml:

Foreground Service Types

By default, flutter_mcp uses dataSync foreground service type which works for most use cases. If you need additional service types (e.g., location, mediaPlayback), add this to your pubspec.yaml:

flutter_mcp:
  android:
    foreground_service_types:
      - dataSync      # Default - data synchronization
      - location      # For location-based services
      - mediaPlayback # For media playback
      - microphone    # For audio recording

Additional Permissions (Coming Soon)

In future versions, you'll be able to request additional Android permissions through pubspec.yaml:

flutter_mcp:
  android:
    permissions:
      - camera        # For camera access
      - location      # For location services
      - microphone    # For audio recording
      - storage       # For file access

These configurations are automatically applied during build time. No manual AndroidManifest.xml changes needed!

Basic Usage #

import 'package:flutter/material.dart';
import 'package:flutter_mcp/flutter_mcp.dart';

void main() async {
  WidgetsFlutterBinding.ensureInitialized();
  
  // Initialize Flutter MCP
  await FlutterMCP.instance.init(
    MCPConfig(
      appName: 'My MCP App',
      appVersion: '1.0.0',
      useBackgroundService: true,
      useNotification: true,
      useTray: true,
      autoStart: true,
      enablePerformanceMonitoring: true, // Enable performance monitoring
      highMemoryThresholdMB: 512, // Set memory threshold for automatic cleanup
      // Auto-start server configuration
      autoStartServer: [
        MCPServerConfig(
          name: 'MCP Server',
          version: '1.0.0',
          capabilities: ServerCapabilities(
            tools: true,
            resources: true,
            prompts: true,
          ),
          integrateLlm: MCPLlmIntegration(
            providerName: 'your-provider',
            config: LlmConfiguration(
              apiKey: 'your-api-key',
              model: 'your-model',
            ),
          ),
        ),
      ],
      // Auto-start client configuration
      autoStartClient: [
        MCPClientConfig(
          name: 'MCP Client',
          version: '1.0.0',
          capabilities: ClientCapabilities(
            sampling: true,
            roots: true,
          ),
          integrateLlm: MCPLlmIntegration(
            existingLlmId: 'llm_1',
          ),
        ),
      ],
      // Scheduled tasks
      schedule: [
        MCPJob.every(
          Duration(minutes: 15),
          task: () {
            // This runs every 15 minutes
          },
        ),
      ],
      // System tray configuration
      tray: TrayConfig(
        tooltip: 'My MCP App',
        menuItems: [
          TrayMenuItem(label: 'Show', onTap: () {
            // Show window code
          }),
          TrayMenuItem.separator(),
          TrayMenuItem(label: 'Exit', onTap: () {
            // Exit app code
          }),
        ],
      ),
    ),
  );
  
  runApp(MyApp());
}

Manual Component Creation #

You can also manually create and manage MCP components:

import 'package:logging/logging.dart';

// Create a logger
final logger = Logger('flutter_mcp.example');

// Create a server
final serverId = await FlutterMCP.instance.createServer(
  name: 'MCP Server',
  version: '1.0.0',
  capabilities: ServerCapabilities(
    tools: true,
    resources: true,
    prompts: true,
  ),
);

// Create a client
final clientId = await FlutterMCP.instance.createClient(
  name: 'MCP Client',
  version: '1.0.0',
  transportCommand: 'server',
  transportArgs: ['--port', '8080'],
);

// Create an LLM
final llmId = await FlutterMCP.instance.createLlm(
  providerName: 'openai',
  config: LlmConfiguration(
    apiKey: 'your-api-key',
    model: 'gpt-4o',
  ),
);

// Connect components
await FlutterMCP.instance.integrateServerWithLlm(
  serverId: serverId,
  llmId: llmId,
);

await FlutterMCP.instance.integrateClientWithLlm(
  clientId: clientId,
  llmId: llmId,
);

// Start components
FlutterMCP.instance.connectServer(serverId);
await FlutterMCP.instance.connectClient(clientId);

// Use components with memory-efficient caching
final response = await FlutterMCP.instance.chat(
  llmId,
  'Hello, how are you today?',
  useCache: true, // Enable caching for repeated questions
);
logger.info('AI: ${response.text}');

// Stream responses from LLM
Stream<LlmResponseChunk> responseStream = FlutterMCP.instance.streamChat(
  llmId,
  'Write me a short story about robots',
);

responseStream.listen((chunk) {
  logger.info(chunk.textChunk); // Process each chunk as it arrives
});

// Clean up when done
await FlutterMCP.instance.shutdown();

Platform Support #

Platform	Background Service	Notifications	System Tray
Android	✅	✅	❌
iOS	⚠️ (Limited)	✅	❌
macOS	✅	✅	✅
Windows	✅	✅	✅
Linux	✅	✅	✅

Transport Configuration #

Transport is the core communication mechanism in MCP. Flutter MCP supports three transport types, each with its own configuration options.

Transport Types #

Transport Type	Description	Use Case
STDIO	Standard Input/Output communication	Local process communication, subprocess execution
SSE	Server-Sent Events over HTTP	Real-time streaming, web-compatible communication
StreamableHTTP	HTTP with streaming support	REST-like API with streaming capabilities

Server Transport Configuration #

STDIO Server

final serverId = await FlutterMCP.instance.createServer(
  name: 'STDIO Server',
  version: '1.0.0',
  config: MCPServerConfig(
    name: 'STDIO Server',
    version: '1.0.0',
    transportType: 'stdio',  // Required: must be explicitly specified
  ),
);

SSE Server

final serverId = await FlutterMCP.instance.createServer(
  name: 'SSE Server',
  version: '1.0.0',
  config: MCPServerConfig(
    name: 'SSE Server',
    version: '1.0.0',
    transportType: 'sse',    // Required: must be explicitly specified
    ssePort: 8080,           // Required for SSE
    host: 'localhost',       // Optional: default 'localhost'
    endpoint: '/sse',        // Optional: default '/sse'
    messagesEndpoint: '/message',  // Optional: default '/message'
    fallbackPorts: [8081, 8082],   // Optional: alternative ports
    authToken: 'secret',     // Optional: authentication
    middleware: [],          // Optional: custom middleware
  ),
);

StreamableHTTP Server

final serverId = await FlutterMCP.instance.createServer(
  name: 'StreamableHTTP Server',
  version: '1.0.0',
  config: MCPServerConfig(
    name: 'StreamableHTTP Server',
    version: '1.0.0',
    transportType: 'streamablehttp',  // Required: must be explicitly specified
    streamableHttpPort: 8080,         // Required for StreamableHTTP
    host: 'localhost',                // Optional: default 'localhost'
    endpoint: '/mcp',                 // Optional: default '/mcp'
    messagesEndpoint: '/message',     // Optional: default '/message'
    fallbackPorts: [8081, 8082],      // Optional: alternative ports
    authToken: 'secret',              // Optional: authentication
    isJsonResponseEnabled: false,     // Optional: false = SSE mode (default), true = JSON mode
    jsonResponseMode: 'sync',         // Optional: 'sync' or 'async' (only for JSON mode)
    maxRequestSize: 4194304,          // Optional: max request size in bytes (default 4MB)
    requestTimeout: Duration(seconds: 30),  // Optional: request timeout
    corsConfig: {                     // Optional: CORS configuration
      'allowOrigin': '*',
      'allowMethods': 'POST, GET, OPTIONS',
      'allowHeaders': 'Content-Type, Authorization',
    },
  ),
);

Client Transport Configuration #

STDIO Client

final clientId = await FlutterMCP.instance.createClient(
  name: 'STDIO Client',
  version: '1.0.0',
  config: MCPClientConfig(
    name: 'STDIO Client',
    version: '1.0.0',
    transportType: 'stdio',        // Required: must be explicitly specified
    transportCommand: 'python',    // Required for STDIO
    transportArgs: ['server.py', '--mode', 'mcp'],  // Optional: command arguments
  ),
);

SSE Client

final clientId = await FlutterMCP.instance.createClient(
  name: 'SSE Client',
  version: '1.0.0',
  config: MCPClientConfig(
    name: 'SSE Client',
    version: '1.0.0',
    transportType: 'sse',              // Required: must be explicitly specified
    serverUrl: 'http://localhost:8080', // Required for SSE
    endpoint: '/sse',                  // Optional: will be appended to serverUrl
    authToken: 'secret',               // Optional: authentication
    headers: {                         // Optional: additional headers
      'X-Custom-Header': 'value',
    },
    timeout: Duration(seconds: 30),    // Optional: request timeout
    sseReadTimeout: Duration(minutes: 5),  // Optional: SSE stream timeout
  ),
);

StreamableHTTP Client

final clientId = await FlutterMCP.instance.createClient(
  name: 'StreamableHTTP Client',
  version: '1.0.0',
  config: MCPClientConfig(
    name: 'StreamableHTTP Client',
    version: '1.0.0',
    transportType: 'streamablehttp',    // Required: must be explicitly specified
    serverUrl: 'http://localhost:8080', // Required for StreamableHTTP (base URL only)
    endpoint: '/mcp',                   // Optional: server should use the same endpoint
    authToken: 'secret',                // Optional: authentication
    headers: {                          // Optional: additional headers
      'X-Custom-Header': 'value',
    },
    timeout: Duration(seconds: 30),     // Optional: request timeout
    maxConcurrentRequests: 10,          // Optional: max concurrent requests
    useHttp2: true,                     // Optional: use HTTP/2 if available
    terminateOnClose: true,             // Optional: terminate session on close
  ),
);

Important Notes #

Transport Type is Required: Starting from v1.0.1, transportType must be explicitly specified. Automatic inference has been removed to prevent unexpected behavior.
URL Handling:
- For SSE: The endpoint is appended to serverUrl if provided
- For StreamableHTTP: The client connects to the base serverUrl, and the server's endpoint configuration must match
Default Endpoints:
- SSE Server: /sse (messages) and /message (commands)
- StreamableHTTP Server: /mcp (all communications)
Authentication: All transports support bearer token authentication via the authToken field
Port Configuration:
- Servers can specify fallbackPorts for automatic failover
- Clients connect to the specific port in the serverUrl

Connection Example #

// 1. Create and start a StreamableHTTP server
final serverId = await FlutterMCP.instance.createServer(
  name: 'My Server',
  version: '1.0.0',
  config: MCPServerConfig(
    name: 'My Server',
    version: '1.0.0',
    transportType: 'streamablehttp',
    streamableHttpPort: 8080,
    endpoint: '/mcp',  // Server listens at http://localhost:8080/mcp
  ),
);
await FlutterMCP.instance.connectServer(serverId);

// 2. Create and connect a client to the server
final clientId = await FlutterMCP.instance.createClient(
  name: 'My Client',
  version: '1.0.0',
  config: MCPClientConfig(
    name: 'My Client',
    version: '1.0.0',
    transportType: 'streamablehttp',
    serverUrl: 'http://localhost:8080',  // Base URL only
    endpoint: '/mcp',  // Must match server's endpoint
  ),
);
await FlutterMCP.instance.connectClient(clientId);

Permissions #

Flutter MCP automatically requests necessary permissions based on your configuration:

Automatic Permission Handling #

When you enable features in MCPConfig, permissions are requested automatically during initialization:

useNotification: true → Requests notification permission
useBackgroundService: true → Requests background execution permissions (Android 13+)

Manual Permission Management #

You can also manage permissions manually:

// Check specific permission
bool hasNotificationPermission = await FlutterMCP.instance.checkPermission('notification');

// Request specific permission
bool granted = await FlutterMCP.instance.requestPermission('notification');

// Request multiple permissions
Map<String, bool> results = await FlutterMCP.instance.requestPermissions([
  'notification',
  'location',
]);

// Request all required permissions based on current config
Map<String, bool> results = await FlutterMCP.instance.requestRequiredPermissions();

Platform-specific Notes #

Android: Permissions are defined in AndroidManifest.xml. Runtime permissions (like notifications on Android 13+) are requested automatically.
iOS: Permissions must be described in Info.plist. Runtime permissions are requested when needed.
Desktop: Most features don't require explicit permissions, except for system tray on some Linux distributions.

Configuration Options #

MCPConfig Options #

MCPConfig(
  appName: 'My App',
  appVersion: '1.0.0',
  useBackgroundService: true,
  useNotification: true,
  useTray: true,
  secure: true,
  lifecycleManaged: true,
  autoStart: true,
  enablePerformanceMonitoring: true,
  enableMetricsExport: false,
  highMemoryThresholdMB: 512,
  lowBatteryWarningThreshold: 20,
  maxConnectionRetries: 3,
  llmRequestTimeoutMs: 60000,
  background: BackgroundConfig(...),
  notification: NotificationConfig(...),
  tray: TrayConfig(...),
  schedule: [...],
  autoStartServer: [...],
  autoStartClient: [...],
)

Logging Configuration #

Flutter MCP uses the standard Dart logging package following MCP conventions:

import 'package:flutter_mcp/flutter_mcp.dart';
import 'package:logging/logging.dart';

// Configure logging
FlutterMcpLogging.configure(
  level: Level.INFO,
  enableDebugLogging: true, // Sets level to FINE
);

// Create a logger with MCP naming convention
final Logger logger = Logger('flutter_mcp.my_component');

// Use the logger
logger.info('Information message');
logger.warning('Warning message');
logger.severe('Error message');
logger.fine('Debug message');
logger.finest('Trace message');

// Extension methods for compatibility
logger.debug('Debug message');  // Maps to fine()
logger.error('Error message');  // Maps to severe()
logger.warn('Warning message'); // Maps to warning()
logger.trace('Trace message');  // Maps to finest()

Background Service Configuration #

BackgroundConfig(
  notificationChannelId: 'my_channel',
  notificationChannelName: 'My Channel',
  notificationDescription: 'Background service notification',
  notificationIcon: 'app_icon',
  autoStartOnBoot: true,
  intervalMs: 5000,
  keepAlive: true,
)

Notification Configuration #

NotificationConfig(
  channelId: 'notifications_channel',
  channelName: 'Notifications',
  channelDescription: 'App notifications',
  icon: 'notification_icon',
  enableSound: true,
  enableVibration: true,
  priority: NotificationPriority.high,
)

System Tray Configuration #

TrayConfig(
  iconPath: 'assets/tray_icon.png',
  tooltip: 'My MCP App',
  menuItems: [
    TrayMenuItem(label: 'Show', onTap: showApp),
    TrayMenuItem.separator(),
    TrayMenuItem(label: 'Exit', onTap: exitApp),
  ],
)

Advanced Usage #

Memory-Efficient Processing #

// Process large data in chunks to avoid memory spikes
final documents = [...]; // List of documents
final processedDocs = await FlutterMCP.instance.processDocumentsInChunks(
  documents,
  (doc) async {
    // Process each document
    return processedDocument;
  },
  chunkSize: 10,
  pauseBetweenChunks: Duration(milliseconds: 100),
);

Memory-Aware Caching #

// Chat with memory-aware caching for faster responses
// The cache will automatically reduce in size during high memory conditions
final response = await FlutterMCP.instance.chat(
  llmId,
  userMessage,
  useCache: true,
);

Performance Monitoring #

import 'package:logging/logging.dart';

final logger = Logger('flutter_mcp.example');

// Get system performance metrics
final status = FlutterMCP.instance.getSystemStatus();
logger.info('Memory usage: ${status['performanceMetrics']['resources']['memory.usageMB']['current']}MB');
logger.info('LLM response time: ${status['performanceMetrics']['timers']['llm.chat']['avg_ms']}ms');

Secure Storage #

// Store values securely
await FlutterMCP.instance.secureStore('api_key', 'your-secret-api-key');

// Retrieve values
final apiKey = await FlutterMCP.instance.secureRead('api_key');

Task Scheduling #

// Add scheduled tasks
final jobId = FlutterMCP.instance.addScheduledJob(
  MCPJob.every(
    Duration(hours: 1),
    task: () {
      // Perform regular task
    },
  ),
);

// Schedule one-time tasks
FlutterMCP.instance.addScheduledJob(
  MCPJob.once(
    Duration(minutes: 5),
    task: () {
      // Will execute only once after 5 minutes
    },
  ),
);

// Remove scheduled tasks
FlutterMCP.instance.removeScheduledJob(jobId);

System Status #

import 'package:logging/logging.dart';

final logger = Logger('flutter_mcp.example');

// Get system status
final status = FlutterMCP.instance.getSystemStatus();
logger.info('Clients: ${status['clients']}');
logger.info('Servers: ${status['servers']}');
logger.info('LLMs: ${status['llms']}');
logger.info('Platform: ${status['platformName']}');
logger.info('Memory: ${status['performanceMetrics']['resources']['memory.usageMB']['current']}MB');

Plugin Registration #

// Register custom plugins
await FlutterMCP.instance.registerPlugin(
  MyCustomPlugin(),
  {'config_key': 'value'},
);

// Execute custom tool plugins
final result = await FlutterMCP.instance.executeToolPlugin(
  'my_tool_plugin',
  {'param1': 'value1'},
);

Examples #

Check out the example directory for a complete sample application.

Configuration Examples #

Scheduled Tasks Configuration

{
  "schedule": [
    {
      "id": "health_check",
      "name": "System Health Check",
      "intervalMinutes": 15,
      "taskType": "healthcheck",
      "taskConfig": {
        "checks": ["memory", "connectivity", "services"]
      }
    },
    {
      "id": "cleanup_task",
      "name": "Cleanup Temporary Files",
      "intervalHours": 6,
      "taskType": "cleanup",
      "taskConfig": {
        "targets": ["temp", "cache", "logs"]
      }
    },
    {
      "id": "memory_monitor",
      "name": "Memory Usage Check",
      "intervalMinutes": 5,
      "taskType": "memory_check",
      "taskConfig": {
        "thresholdMB": 512
      }
    }
  ]
}

Platform Version Checking

// Check platform compatibility
if (await PlatformUtils.isAndroidAtLeast(31)) {
  // Use Android 12+ features
}

if (await PlatformUtils.isIOSAtLeast('15.0')) {
  // Use iOS 15+ features
}

// Create a logger
final logger = Logger('flutter_mcp.example');

// Get detailed platform info
final platformInfo = await PlatformUtils.getPlatformVersionInfo();
logger.info('Platform: ${platformInfo['platform']}');
logger.info('OS Version: ${platformInfo['operatingSystemVersion']}');

Web Memory Monitoring

// Enhanced web memory monitoring
final webMonitor = WebMemoryMonitor.instance;

// Start monitoring with improved accuracy
webMonitor.startMonitoring();

// Create a logger
final logger = Logger('flutter_mcp.example');

// Get real-time memory statistics
final stats = webMonitor.getStatistics();
logger.info('Memory Usage: ${stats['currentUsageMB']}MB');
logger.info('Source: ${stats['source']}'); // performance.memory, performance_observer, etc.

// Export detailed memory data
final exportData = webMonitor.exportData();

Architecture #

For a detailed understanding of the Flutter MCP architecture, please refer to ARCHITECTURE.md.

Key Architectural Features #

Modular Design: Clean separation between MCP components and platform services
Cross-Platform: Native implementations for all supported platforms
Plugin System: Extensible architecture for custom functionality
Performance Optimized: Memory management and real-time monitoring
Configuration-Driven: YAML/JSON configuration with task automation

Testing #

The project includes comprehensive test coverage:

# Run all tests
flutter test

# Run specific test suites
flutter test test/config_task_execution_test.dart
flutter test test/platform_version_test.dart
flutter test test/web_memory_monitor_test.dart

Test Coverage Areas #

Configuration Task Execution: Automated task scheduling and execution
Platform Version Detection: Cross-platform version compatibility
Web Memory Monitoring: Enhanced browser memory tracking
Integration Tests: End-to-end functionality validation

Performance Monitoring #

Flutter MCP includes advanced performance monitoring capabilities:

Real-time Metrics #

Memory usage tracking with platform-specific APIs
CPU utilization monitoring
Network request tracking
Error rate monitoring

Automated Optimization #

Memory-aware caching with automatic eviction
Background task throttling based on system resources
Circuit breaker pattern for error recovery
Performance-based configuration adjustments

Troubleshooting #

Common Issues #

Memory Issues

// Enable aggressive memory monitoring
await FlutterMCP.instance.init(MCPConfig(
  highMemoryThresholdMB: 256, // Lower threshold for stricter monitoring
  enablePerformanceMonitoring: true,
));

Platform Compatibility

// Check platform support before using features
if (PlatformUtils.supportsNotifications) {
  await FlutterMCP.instance.showNotification(
    title: 'Test',
    body: 'Platform supports notifications',
  );
}

Configuration Issues

// Validate configuration before initialization
try {
  final config = await ConfigLoader.loadFromJsonFile('assets/mcp_config.json');
  await FlutterMCP.instance.init(config);
} catch (e) {
  final logger = Logger('flutter_mcp.example');
  logger.error('Configuration error: $e');
  // Fallback to default configuration
  await FlutterMCP.instance.init(MCPConfig.defaultConfig());
}

Issues and Feedback #

Please file any issues, bugs, or feature requests in our issue tracker.

Architecture #

MCP Core Integration #

Flutter MCP includes built-in MCP protocol support:

MCP Client: Built-in client implementation with transport layer support
MCP Server: Built-in server implementation with capability management
MCP LLM: Built-in LLM integration layer for MCP protocol communication

These capabilities are included in the flutter_mcp package - no additional dependencies needed!

Native Platform Implementation #

Version 1.0.0 implements platform-specific features using native code instead of external Flutter packages:

Background Services: Native Android (Kotlin), iOS (Swift), Windows (C++), Linux (C++), and macOS (Swift) implementations
Notifications: Platform-native notification systems with full customization support
System Tray: Native system tray integration for desktop platforms (Windows, macOS, Linux)
Secure Storage: Direct integration with platform keychain/credential systems
File System: Uses path_provider: ^2.1.5 for cross-platform file access

This native approach provides better performance, reduced dependencies, and platform-optimized user experiences.

Documentation #

Comprehensive documentation is available in the doc directory:

📚 Getting Started #

Installation Guide - Step-by-step installation instructions
Getting Started - Quick start guide
Architecture Overview - System architecture and design patterns
Best Practices - Recommended patterns and practices

🔧 API Reference #

Core API - Main FlutterMCP class and initialization
Client Manager - MCP client management
Server Manager - MCP server management
LLM Manager - LLM integration and management
Plugin System - Plugin development and integration
Platform Services - Platform-specific features
Background Service - Background task management
Security API - Security and encryption features
Utilities - Helper functions and utilities

💡 Examples #

Simple Connection - Basic MCP connection example
Multiple Servers - Managing multiple MCP servers
Plugin Development - Creating custom plugins
Background Jobs - Scheduling background tasks
Real-time Updates - Implementing real-time features
State Management - Managing application state
Security Examples - Implementing security features

🚀 Platform Integration #

Android Integration - Android-specific features
iOS Integration - iOS-specific features
Desktop Applications - Windows, macOS, Linux features
Web Applications - Web platform features

🤖 LLM Integrations #

Anthropic Claude - Claude integration guide
OpenAI GPT - GPT integration guide
Google Gemini - Gemini integration guide
Local LLM - Local LLM deployment guide

🛠️ Advanced Topics #

Error Handling - Comprehensive error handling
Memory Management - Memory optimization techniques
Performance Tuning - Performance optimization
Security - Security best practices
Testing - Testing strategies and examples

🔍 Troubleshooting #

Common Issues - Solutions to common problems
Debug Mode - Debugging techniques
Error Codes - Error code reference
Performance Issues - Performance troubleshooting
Migration Guide - Version migration guide

🧩 Plugin Development #

Plugin Lifecycle - Understanding plugin lifecycle
Plugin Communication - Inter-plugin communication
Plugin Development Guide - Creating custom plugins
Plugin Examples - Sample plugin implementations

📱 Platform Guides #

Android - Android platform guide
iOS - iOS platform guide
Windows - Windows platform guide
macOS - macOS platform guide
Linux - Linux platform guide
Web - Web platform guide

🤝 Contributing #

Contributing Guide - How to contribute to the project

License #

This project is licensed under the MIT License - see the LICENSE file for details.

flutter_mcp 1.0.3 flutter_mcp: ^1.0.3 copied to clipboard

Metadata

Flutter MCP #

🙌 Support This Project #

🔗 MCP Dart Package Family #

Features #

Getting Started #

Installation #

Platform Setup (Optional) #

Android Configuration

Foreground Service Types

Additional Permissions (Coming Soon)

Basic Usage #

Manual Component Creation #

Platform Support #

Transport Configuration #

Transport Types #

Server Transport Configuration #

STDIO Server

SSE Server

StreamableHTTP Server

Client Transport Configuration #

STDIO Client

SSE Client

StreamableHTTP Client

Important Notes #

Connection Example #

Permissions #

Automatic Permission Handling #

Manual Permission Management #

Platform-specific Notes #

Configuration Options #

MCPConfig Options #

Logging Configuration #

Background Service Configuration #

Notification Configuration #

System Tray Configuration #

Advanced Usage #

Memory-Efficient Processing #

Memory-Aware Caching #

Performance Monitoring #

Secure Storage #

Task Scheduling #

System Status #

Plugin Registration #

Examples #

Configuration Examples #

Scheduled Tasks Configuration

Platform Version Checking

Web Memory Monitoring

Architecture #

Key Architectural Features #

Testing #

Test Coverage Areas #

Performance Monitoring #

Real-time Metrics #

Automated Optimization #

Troubleshooting #

Common Issues #

Memory Issues

Platform Compatibility

Configuration Issues

Issues and Feedback #

Architecture #

MCP Core Integration #

Native Platform Implementation #

Documentation #

📚 Getting Started #

🔧 API Reference #

💡 Examples #

🚀 Platform Integration #

🤖 LLM Integrations #

🛠️ Advanced Topics #

🔍 Troubleshooting #

🧩 Plugin Development #

📱 Platform Guides #

🤝 Contributing #

License #

← Metadata

Publisher

flutter_mcp 1.0.3
flutter_mcp: ^1.0.3 copied to clipboard