git clone https://github.com/RedCiprianPater/mcp-server-robotics.git
cd mcp-server-robotics

npm install

cp .env.example .env
# Edit .env and add your NWO_API_KEY
nano .env

npm run build
npm start

# The server will start and display available tools
# You can now use any of the 77 tools through Claude

✅ nwo_initialize_slam              - Persistent robot mapping
✅ nwo_localize                     - Landmark-based localization
✅ nwo_create_rl_env                - Cloud RL training environments
✅ nwo_train_policy                 - Policy training (SB3)
✅ nwo_detect_objects_grounding     - Open-vocabulary detection

✅ nwo_query_thermal                - Heat detection
✅ nwo_query_mmwave                 - Millimeter-wave radar
✅ nwo_query_gas                    - Air quality sensors
✅ nwo_query_acoustic               - Sound localization
✅ nwo_query_magnetic               - Metal detection

✅ nwo_read_tactile                 - ORCA Hand 576 taxels
✅ nwo_identify_material            - Material recognition
✅ nwo_plan_motion                  - MoveIt2 motion planning
✅ nwo_execute_behavior_tree        - Hierarchical task execution

Inference & Models (6)              Robot Control (3)
Task Planning & Learning (4)        Agent Management (3)
Voice & Gesture (2)                 Simulation & Physics (3)
ROS2 & Hardware (3)                 MQTT & IoT (2)
Safety & Monitoring (3)             Embodiment & Calibration (3)
Autonomous Agents (4)               Dataset & Export (2)
Demo & Testing (2)

export NWO_API_KEY="sk_live_your_key_here"

# Standard API (full features)
NWO_API_BASE=https://nwo.capital/webapp

# Edge API (ultra-low latency, 200+ locations)
NWO_EDGE_API=https://nwo-robotics-api-edge.ciprianpater.workers.dev/api

# ROS2 Bridge (for physical robots)
NWO_ROS2_BRIDGE=https://nwo-ros2-bridge.onrender.com

# MQTT Broker (IoT sensors)
MQTT_BROKER=mqtt.nwo.capital
MQTT_PORT=8883

// Initialize SLAM mapping
const slam = await client.messages.create({
  tools: [{name: "nwo_initialize_slam", input: {
    agent_id: "robot_001",
    map_name: "warehouse",
    slam_type: "hybrid",
    loop_closure: true
  }}]
});

// Later: Localize in the map
const localize = await client.messages.create({
  tools: [{name: "nwo_localize", input: {
    agent_id: "robot_001",
    map_id: "map_123",
    image: "base64_encoded_image"
  }}]
});

// Detect objects with natural language
const detect = await client.messages.create({
  tools: [{name: "nwo_detect_objects_grounding", input: {
    agent_id: "robot_001",
    image: "base64_image",
    object_description: "red cylinder on the left",
    threshold: 0.85,
    return_mask: true
  }}]
});

// Execute action based on detection
const execute = await client.messages.create({
  tools: [{name: "nwo_inference", input: {
    instruction: "Pick up the detected object",
    images: ["base64_image"]
  }}]
});

// Break down high-level instruction
const plan = await client.messages.create({
  tools: [{name: "nwo_task_planner", input: {
    instruction: "Clean the warehouse floor",
    agent_id: "robot_001",
    context: {
      location: "warehouse",
      known_objects: ["shelves", "boxes"]
    }
  }}]
});

// Execute subtasks
for (let i = 1; i <= 5; i++) {
  await client.messages.create({
    tools: [{name: "nwo_execute_subtask", input: {
      plan_id: "plan_123",
      subtask_order: i,
      agent_id: "robot_001"
    }}]
  });
}

const fusion = await client.messages.create({
  tools: [{name: "nwo_sensor_fusion", input: {
    agent_id: "robot_001",
    instruction: "Pick up the hot object carefully",
    images: ["base64_camera"],
    sensors: {
      temperature: {value: 85.5, unit: "celsius"},
      proximity: {distance: 0.15, unit: "meters"},
      force: {grip_pressure: 2.5},
      gps: {lat: 51.5074, lng: -0.1278}
    }
  }}]
});

// Create RL environment
const env = await client.messages.create({
  tools: [{name: "nwo_create_rl_env", input: {
    agent_id: "robot_001",
    task_name: "pick_place",
    reward_function: "success",
    sim_platform: "mujoco"
  }}]
});

// Train policy
const train = await client.messages.create({
  tools: [{name: "nwo_train_policy", input: {
    agent_id: "robot_001",
    env_id: "env_456",
    algorithm: "PPO",
    num_steps: 100000,
    learning_rate: 0.0003
  }}]
});

docker build -t mcp-nwo-robotics .
docker run -e NWO_API_KEY=sk_xxx mcp-nwo-robotics

# Start full stack with MQTT broker
docker-compose up -d

# View logs
docker-compose logs -f mcp-nwo-robotics

# Stop
docker-compose down

# Build for production
docker build -t mcp-nwo-robotics:prod .

# Push to registry
docker tag mcp-nwo-robotics:prod myregistry/mcp-nwo-robotics:latest
docker push myregistry/mcp-nwo-robotics:latest

# Deploy on Kubernetes
kubectl apply -f k8s-deployment.yaml

# Never commit API keys
echo "NWO_API_KEY=*" >> .gitignore
echo ".env" >> .gitignore

# Use environment variables or .env (in .gitignore)

const balance = await client.messages.create({
  tools: [{name: "nwo_agent_check_balance", input: {
    agent_id: "agent_123"
  }}]
});

npm test
npm run test:watch

# Test SLAM
npm run dev -- --test nwo_initialize_slam

# Test inference
npm run dev -- --test nwo_inference

# Test sensor fusion
npm run dev -- --test nwo_sensor_fusion

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const response = await client.messages.create({
  model: "claude-3-5-sonnet-20241022",
  max_tokens: 4096,
  tools: tools, // All 77 NWO tools
  messages: [{
    role: "user",
    content: "Initialize SLAM mapping on robot_001"
  }]
});

from langchain.chat_models import ChatAnthropic
from langchain.tools import StructuredTool

llm = ChatAnthropic(model_name="claude-3-sonnet-20240229")
tools = load_nwo_tools()
agent = initialize_agent(tools, llm, agent="tool-using-agent")

from crewai import Agent, Task, Crew
from nwo_tools import get_robotics_tools

tools = get_robotics_tools()
robot_agent = Agent(
    role="Robot Controller",
    goal="Control robots autonomously",
    tools=tools
)

# Solution: Check API key
echo $NWO_API_KEY

# If empty, set it:
export NWO_API_KEY="sk_your_actual_key"

# Or in .env:
NWO_API_KEY=sk_your_actual_key

# Solution: Use edge API for faster response
# Set: NWO_EDGE_API endpoint
# Tool: nwo_edge_inference instead of nwo_inference

# Solution: Validate trajectory before execution
# Use: nwo_simulate_trajectory to check collision
# Use: nwo_check_collision for detailed analysis

# Solution: Ensure good image quality
# - Well-lit environment
# - Distinct visual features
# - Slow movement during initialization
# - Try visual instead of hybrid SLAM

# View real-time logs
npm run dev

# With custom log level
LOG_LEVEL=debug npm start

# Save to file
npm start > logs/server.log 2>&1

# Monitor API usage
nwo_agent_check_balance

# Export dataset for analysis
nwo_export_dataset

# Check system health
GET /health (if enabled)