Which integrations are available for this server?

Supports containerized deployment and integration through Docker, with ready-made images and Docker Compose configurations. Enables integration with LangChain, allowing agents to access TAK Server geospatial capabilities through MCPTool. Provides integration with Node.js environment, requiring Node.js 18.0.0 or higher for operation.

How do I use TAK Server MCP?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@TAK Server MCP find friendly units within 5km of our current position" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

TAK Server MCP (Model Context Protocol)

A Model Context Protocol (MCP) server for integrating TAK Server with AI systems, enabling geospatial-aware deep research and analysis capabilities.

License: MIT MCP Version Node Version

🚀 Features

Multi-Transport Support

stdio - Standard input/output for CLI integration
HTTP+SSE - Server-Sent Events for web integration
WebSocket - Real-time bidirectional communication

Complete Tool Suite (11 Tools)

📍 Geospatial Operations

tak_spatial_query - Query entities within geographic areas
tak_calculate_distance - Distance calculations with travel time estimates
tak_find_nearest - Find nearest entities with bearings
tak_create_geofence - Create geofenced areas with alerts
tak_analyze_movement - Track movements and detect anomalies

📡 Real-time Operations

tak_get_cot_events - Retrieve Cursor on Target events
tak_send_cot_event - Send CoT messages
tak_subscribe_events - Subscribe to live event streams
tak_get_entities - Get current entity states

🚨 Mission & Emergency

tak_get_missions - List and manage missions
tak_get_alerts - Retrieve and filter alerts
tak_send_emergency - Send emergency broadcasts
tak_manage_data_packages - Upload/download data packages

Advanced Features

🔐 Multiple authentication methods (OAuth 2.0, API tokens, certificates)
📊 H3 hexagonal indexing for spatial queries
🗺️ MGRS coordinate conversion
⚡ Real-time WebSocket subscriptions
💾 Intelligent caching with TTL
🔍 Comprehensive error handling

Related MCP server: MCP Server For Local

📋 Prerequisites

Node.js >= 18.0.0
TAK Server instance (one of):
- TAK Server (Official)
- FreeTAKServer (Open Source)
- taky (Lightweight, CoT only)

🛠️ Installation

Using NPM

npm install @skyfi/tak-server-mcp

From Source

git clone https://github.com/skyfi/tak-server-mcp.git
cd tak-server-mcp
npm install
npm run build

Using Docker

docker pull skyfi/tak-server-mcp:latest

⚙️ Configuration

Environment Variables

# TAK Server Connection
TAK_SERVER_URL=https://your-tak-server.com
TAK_SERVER_API_TOKEN=your-api-token
TAK_SERVER_CLIENT_CERT=/path/to/cert.pem
TAK_SERVER_CLIENT_KEY=/path/to/key.pem

# MCP Configuration
MCP_TRANSPORT=stdio
MCP_PORT=3000
MCP_AUTH_ENABLED=false

Configuration File

Create a config.json:

{
  "takServer": {
    "url": "https://your-tak-server.com",
    "apiToken": "your-token",
    "verifySsl": true
  },
  "mcp": {
    "transport": "stdio",
    "port": 3000
  },
  "tools": {
    "enabledTools": ["tak_get_cot_events", "tak_spatial_query"]
  }
}

🚀 Quick Start

1. With Claude Desktop

Add to your Claude Desktop config:

{
  "mcpServers": {
    "tak-server": {
      "command": "npx",
      "args": ["@skyfi/tak-server-mcp"],
      "env": {
        "TAK_SERVER_URL": "https://your-tak-server.com",
        "TAK_SERVER_API_TOKEN": "your-token"
      }
    }
  }
}

2. With Docker

docker run -it --rm \
  -e TAK_SERVER_URL=https://your-tak-server.com \
  -e TAK_SERVER_API_TOKEN=your-token \
  skyfi/tak-server-mcp:latest

3. Command Line

# Install globally
npm install -g @skyfi/tak-server-mcp

# Run with environment variables
TAK_SERVER_URL=https://your-tak-server.com \
TAK_SERVER_API_TOKEN=your-token \
tak-server-mcp

# Or with config file
tak-server-mcp --config ./config.json

📚 Usage Examples

Calculate Distance Between Points

{
  "tool": "tak_calculate_distance",
  "arguments": {
    "from": { "coordinates": [37.7749, -122.4194] },
    "to": { "coordinates": [37.7849, -122.4094] },
    "units": "kilometers"
  }
}

Find Nearest Friendly Units

{
  "tool": "tak_find_nearest",
  "arguments": {
    "point": { "coordinates": [37.7749, -122.4194] },
    "maxDistance": 5000,
    "entityTypes": ["a-f-*"],
    "maxResults": 5
  }
}

Create Security Geofence

{
  "tool": "tak_create_geofence",
  "arguments": {
    "name": "Base Perimeter",
    "shape": {
      "type": "circle",
      "center": [37.7749, -122.4194],
      "radius": 2000
    },
    "alertLevel": "high",
    "triggers": {
      "onEntry": true,
      "onExit": true
    }
  }
}

🧪 Testing

Run Tests

# Run all tests
npm test

# Run with coverage
npm run test:coverage

# Run integration tests
npm run test:integration

Test with TAK Server

# Test connection
./test-all-tools.js

# Run specific tool tests
./test-all-tools.js --tool tak_spatial_query

🐳 Docker Deployment

Build Image

docker build -t tak-server-mcp .

Run Container

docker run -d \
  --name tak-mcp \
  -e TAK_SERVER_URL=https://tak.example.com \
  -e TAK_SERVER_API_TOKEN=your-token \
  -p 3000:3000 \
  tak-server-mcp

Docker Compose

version: '3.8'
services:
  tak-mcp:
    image: skyfi/tak-server-mcp:latest
    environment:
      TAK_SERVER_URL: ${TAK_SERVER_URL}
      TAK_SERVER_API_TOKEN: ${TAK_SERVER_API_TOKEN}
      MCP_TRANSPORT: http
      MCP_PORT: 3000
    ports:
      - "3000:3000"

🤝 Integration Examples

With LangChain

from langchain.tools import MCPTool

tak_tool = MCPTool(
    name="tak-server",
    server_url="http://localhost:3000",
    auth_token="your-mcp-token"
)

result = agent.run("Find all units within 10km of coordinates 37.7749, -122.4194")

With Anthropic SDK

import { MCPClient } from '@modelcontextprotocol/sdk';

const mcp = new MCPClient({
  serverUrl: 'http://localhost:3000',
  transport: 'http'
});

const tools = await mcp.listTools();
const result = await mcp.callTool('tak_spatial_query', {
  center: [37.7749, -122.4194],
  radius: 10000
});

🏗️ Architecture

┌─────────────────┐     ┌──────────────┐     ┌─────────────┐
│   AI Systems    │────▶│  MCP Server  │────▶│ TAK Server  │
│  (LLMs, Agents) │◀────│              │◀────│             │
└─────────────────┘     └──────────────┘     └─────────────┘
         │                      │                     │
         │                      ▼                     │
         │              ┌──────────────┐              │
         └─────────────▶│ Tool Handlers│◀─────────────┘
                        └──────────────┘

🔒 Security

TLS 1.2+ for all communications
OAuth 2.0 and certificate-based authentication
Input validation and sanitization
Rate limiting and access controls
Audit logging for all operations

📖 Documentation

🤝 Contributing

We welcome contributions! Please see our Contributing Guide for details.

Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

📄 License

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

🙏 Acknowledgments

TAK Product Center for TAK Server documentation
Anthropic for the MCP specification
The open-source geospatial community

📞 Support

Issues: GitHub Issues
Discussions: GitHub Discussions
Email: support@skyfi.com

🚦 Status

✅ All 11 advertised tools implemented
✅ Multi-transport support (stdio, HTTP, SSE)
✅ Docker support
✅ FreeTAKServer compatible
🚧 Test coverage in progress
🚧 Additional tool development ongoing

Made with ❤️ by SkyFi