地图控制库

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
        maven { url = uri("https://jitpack.io") }  // Add this line
    }
}

dependencies {
    // Mapbox MCP Tools Library
    implementation("com.github.moritzzzzz:android-mapbox-map-tools-mcp-v11:v1.0.0")

    // Required: Mapbox Maps SDK (if not already included)
    implementation("com.mapbox.maps:android:11.17.1")

    // Required: Kotlin Serialization
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.2")
}

import com.mapbox.maps.MapView
import com.mapbox.mcp.MapboxMapTools

class YourActivity : AppCompatActivity() {
    private lateinit var mapView: MapView
    private lateinit var mapboxMapTools: MapboxMapTools

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Initialize MapView
        mapView = findViewById(R.id.mapView)

        // Wait for map style to load
        mapView.mapboxMap.loadStyleUri(Style.MAPBOX_STREETS) {
            // Create MapboxMapTools wrapper
            mapboxMapTools = MapboxMapTools(mapView)

            // Get tool definitions for your LLM
            val tools = mapboxMapTools.getToolsForLLM()
            // Send these to Claude API or your LLM provider...

            // Execute a tool
            val result = mapboxMapTools.executeTool(
                "pan_map_to_location",
                mapOf(
                    "latitude" to 48.8566,
                    "longitude" to 2.3522,
                    "zoom" to 12.0
                )
            )
        }
    }
}

object Config {
    // Claude API Key (loaded from local.properties at build time)
    val CLAUDE_API_KEY = BuildConfig.CLAUDE_API_KEY

    // Model selection (sonnet is faster, opus is more capable)
    const val CLAUDE_MODEL = "claude-sonnet-4-5-20250929"
    // Options: "claude-sonnet-4-5-20250929", "claude-opus-4-5-20251101"

    // Maximum tokens for responses
    const val MAX_TOKENS = 4096
}

import com.mapbox.maps.MapView
import com.mapbox.maps.Style
import com.mapbox.mcp.MapboxMapTools
import com.mapbox.mcp.models.ToolResult

class YourActivity : AppCompatActivity() {
    private lateinit var mapView: MapView
    private lateinit var mapboxMapTools: MapboxMapTools

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Create and setup MapView
        mapView = MapView(this)
        setContentView(mapView)

        // Load map style first
        mapView.mapboxMap.loadStyleUri(Style.MAPBOX_STREETS) {
            // Initialize tools after style loads
            mapboxMapTools = MapboxMapTools(mapView)

            // Now you can use the tools!
            useMapTools()
        }
    }

    private fun useMapTools() {
        // Get tool definitions (for sending to LLM)
        val tools = mapboxMapTools.getToolsForLLM()
        println("Available tools: ${tools.map { it.name }}")

        // Execute a tool directly
        val result = mapboxMapTools.executeTool(
            "add_points_to_map",
            mapOf(
                "points" to listOf(
                    mapOf(
                        "lat" to 40.7128,
                        "lng" to -74.0060,
                        "title" to "New York City",
                        "description" to "The Big Apple"
                    )
                ),
                "iconColor" to "#FF5722",
                "iconSize" to 1.5
            )
        )

        // Handle result
        when (result) {
            is ToolResult.Success -> {
                Log.d("Map", "Success: ${result.data}")
            }
            is ToolResult.Error -> {
                Log.e("Map", "Error: ${result.message}")
            }
        }
    }
}

mapboxMapTools.executeTool("add_points_to_map", mapOf(
    "points" to listOf(
        mapOf("lat" to 48.8566, "lng" to 2.3522, "title" to "Paris"),
        mapOf("lat" to 51.5074, "lng" to -0.1278, "title" to "London")
    ),
    "layerName" to "cities",
    "iconColor" to "#4CAF50"
))

mapboxMapTools.executeTool("add_route_to_map", mapOf(
    "coordinates" to listOf(
        listOf(-122.4194, 37.7749),  // San Francisco
        listOf(-118.2437, 34.0522)   // Los Angeles
    ),
    "lineColor" to "#2196F3",
    "lineWidth" to 5.0
))

mapboxMapTools.executeTool("pan_map_to_location", mapOf(
    "latitude" to 40.7128,
    "longitude" to -74.0060,
    "zoom" to 12.0,
    "animated" to true
))

// Clear all layers
mapboxMapTools.executeTool("clear_map_layers", emptyMap())

// Clear specific layers
mapboxMapTools.executeTool("clear_map_layers", mapOf(
    "layerNames" to listOf("cities", "routes")
))

Claude API
    ↓
Your App sends combined tool list:
    ├─ Mapbox Tools (this library)
    ├─ Weather API Tools (hypothetical)
    └─ Database Tools (hypothetical)
    ↓
Your App routes execution to correct provider

class WeatherTools {
    fun getToolsForLLM(): List<ToolDefinition> {
        return listOf(
            ToolDefinition(
                name = "get_weather",
                description = "Get current weather for a location",
                inputSchema = InputSchema(
                    type = "object",
                    properties = mapOf(
                        "city" to Property("string", "City name"),
                        "country" to Property("string", "Country code (optional)")
                    ),
                    required = listOf("city")
                )
            )
        )
    }

    fun executeTool(name: String, params: Map<String, Any?>): ToolResult {
        return when (name) {
            "get_weather" -> {
                val city = params["city"] as? String ?: return ToolResult.Error("Missing city")
                // Call your weather API here...
                ToolResult.Success("Weather in $city: Sunny, 72°F")
            }
            else -> ToolResult.Error("Unknown tool: $name")
        }
    }
}

class ChatManager(
    private val claudeApiClient: ClaudeApiClient,
    private val mapboxMapTools: MapboxMapTools,
    private val weatherTools: WeatherTools  // Add additional providers
) {
    suspend fun processMessage(userMessage: String): String {
        // ... existing code ...

        // Combine all tool definitions
        val allTools = buildList {
            addAll(mapboxMapTools.getToolsForLLM())
            addAll(weatherTools.getToolsForLLM())
            // Add more tool providers here...
        }

        Log.d(TAG, "Available tools: ${allTools.map { it.name }}")

        // Send to Claude with all tools
        val response = claudeApiClient.sendMessage(
            messages = conversationHistory.toList(),
            tools = allTools
        )

        // ... rest of existing code ...
    }

    private suspend fun executeToolCall(toolUseBlock: ContentBlock): String {
        val toolName = toolUseBlock.name ?: return "Error: No tool name"
        val params = convertJsonElementMapToAny(toolUseBlock.input ?: emptyMap())

        Log.d(TAG, "Executing tool: $toolName with params: $params")

        // Route to appropriate tool provider based on tool name
        val result = when {
            toolName.startsWith("add_") ||
            toolName.startsWith("pan_") ||
            toolName.startsWith("fit_") ||
            toolName.startsWith("clear_") ||
            toolName.startsWith("set_") -> {
                // Mapbox tools
                mapboxMapTools.executeTool(toolName, params)
            }
            toolName == "get_weather" -> {
                // Weather tools
                weatherTools.executeTool(toolName, params)
            }
            else -> {
                ToolResult.Error("Unknown tool: $toolName")
            }
        }

        return when (result) {
            is ToolResult.Success -> result.data ?: "Success"
            is ToolResult.Error -> "Error: ${result.message}"
        }
    }
}

class MainActivity : AppCompatActivity() {
    private lateinit var mapboxMapTools: MapboxMapTools
    private lateinit var weatherTools: WeatherTools
    private lateinit var chatManager: ChatManager

    private fun initializeChatManager() {
        val claudeApiClient = ClaudeApiClient(CLAUDE_API_KEY)
        weatherTools = WeatherTools()  // Initialize additional provider

        chatManager = ChatManager(
            claudeApiClient,
            mapboxMapTools,
            weatherTools  // Pass additional provider
        )

        Log.d(TAG, "ChatManager initialized with ${
            mapboxMapTools.getToolsForLLM().size + weatherTools.getToolsForLLM().size
        } tools")
    }
}

User: "Show me Paris and tell me the weather there"
  ↓
Claude calls:
  1. pan_map_to_location (Mapbox)
  2. get_weather (Weather API)
  ↓
App: "I've centered the map on Paris. The weather is Sunny, 72°F."

class ToolRegistry {
    private val providers = mutableMapOf<String, ToolProvider>()

    fun register(toolNamePrefix: String, provider: ToolProvider) {
        providers[toolNamePrefix] = provider
    }

    fun getAllTools(): List<ToolDefinition> {
        return providers.values.flatMap { it.getToolsForLLM() }
    }

    fun executeTool(toolName: String, params: Map<String, Any?>): ToolResult {
        // Find provider by checking tool name prefixes or patterns
        val provider = providers.entries.find { (prefix, _) ->
            toolName.startsWith(prefix)
        }?.value

        return provider?.executeTool(toolName, params)
            ?: ToolResult.Error("No provider found for tool: $toolName")
    }
}

// Usage
val registry = ToolRegistry()
registry.register("map", mapboxMapTools)
registry.register("weather", weatherTools)
registry.register("db", databaseTools)

val allTools = registry.getAllTools()
val result = registry.executeTool("map_add_points", params)

Input tokens:  1,060 tokens × $3/million  = $0.00318 per request
Output tokens: varies (typically 500-2000 tokens)

Example with typical 1,000 token response:
  Input (tools + message): 1,160 tokens = $0.0035
  Output (response):       1,000 tokens = $0.0150
  ─────────────────────────────────────────────
  Total per request:                    $0.0185

val toolsJson = json.encodeToString(tools)
val estimatedTokens = toolsJson.length / 3.5  // Rough estimate
Log.d("Tokens", "Sending ~${estimatedTokens.toInt()} tokens in tools")

mapOf(
    "points" to listOf(
        mapOf("lat" to 40.7128, "lng" to -74.0060, "title" to "NYC")
    ),
    "iconColor" to "#FF5722"
)

MapboxMapTools
├── getToolsForLLM() → List<ToolDefinition>
│   Returns MCP tool schemas for LLM
│
└── executeTool(name, params) → ToolResult
    Executes tools and returns Success/Error

┌─────────────────────────────────┐
│ User types message in chat      │
└──────────────┬──────────────────┘
               ▼
┌─────────────────────────────────┐
│ ChatManager.processMessage()    │
├─────────────────────────────────┤
│ 1. Get tools from library       │
│ 2. Send to Claude API           │
│ 3. Parse tool_use blocks        │
│ 4. Execute via MapboxMapTools   │
│ 5. Send results back to Claude  │
│ 6. Return final response        │
└──────────────┬──────────────────┘
               ▼
┌─────────────────────────────────┐
│ Display response + Update map   │
└─────────────────────────────────┘

User: "Show me Paris"
  ↓
Claude: [analyzes] → tool_use: pan_map_to_location(lat: 48.8566, lng: 2.3522)
  ↓
App: Executes tool → Map pans to Paris
  ↓
Claude: "I've centered the map on Paris, France (48.8566°N, 2.3522°E)"
  ↓
User sees response + map at Paris

// DON'T commit API keys to version control
const val CLAUDE_API_KEY = "sk-ant-api03-xxxx"

// build.gradle.kts
android {
    defaultConfig {
        buildConfigField(
            "String",
            "CLAUDE_API_KEY",
            "\"${System.getenv("CLAUDE_API_KEY")}\""
        )
    }
}

// Config.kt
const val CLAUDE_API_KEY = BuildConfig.CLAUDE_API_KEY

# local.properties (add to .gitignore)
CLAUDE_API_KEY=sk-ant-api03-xxxx

// build.gradle.kts
val localProperties = Properties()
localProperties.load(FileInputStream(rootProject.file("local.properties")))

android {
    defaultConfig {
        buildConfigField(
            "String",
            "CLAUDE_API_KEY",
            "\"${localProperties.getProperty("CLAUDE_API_KEY")}\""
        )
    }
}

export CLAUDE_API_KEY="sk-ant-api03-xxxx"

android_mapbox_mcp_wrapper/
├── README.md                           # This file
└── mcp_tools_demo_app/                 # Android Studio project
    ├── mapbox-mcp-tools/               # Library module
    │   ├── build.gradle.kts
    │   └── src/main/java/com/mapbox/mcp/
    │       ├── MapboxMapTools.kt       # Main API
    │       ├── models/
    │       │   ├── ToolDefinition.kt   # MCP tool schema
    │       │   ├── ToolResult.kt       # Result type
    │       │   ├── Point.kt            # Point data
    │       │   ├── Route.kt            # Route data
    │       │   └── Polygon.kt          # Polygon data
    │       └── internal/
    │           └── (implementation)
    │
    └── app/                            # Demo application
        ├── build.gradle.kts
        └── src/main/java/com/example/mcp_tools_demo/
            ├── MainActivity.kt          # Main UI + integration
            ├── Config.kt               # Configuration (API keys)
            ├── ClaudeApiClient.kt      # Claude API client
            ├── ChatManager.kt          # Conversation orchestrator
            ├── ChatAdapter.kt          # Chat UI adapter
            └── models/
                └── ChatMessage.kt      # UI message model