SLAM, 강화 학습, 고급 센서 및 전체 로봇 시스템 제어를 포함하는 77개의 통합 도구를 갖춘 NWO 로보틱스 API용 완전한 모델 컨텍스트 프로토콜(MCP) 서버입니다.
이 MCP 서버는 우선순위와 기능별로 정리된 77개의 도구를 갖춘 통합 인터페이스를 통해 모든 NWO 로보틱스 API 엔드포인트에 대한 포괄적인 액세스를 제공합니다.
77개의 통합 도구 - 전체 API 커버리지
SLAM 및 위치 추정 - 지속적인 로봇 매핑 및 내비게이션
강화 학습 - 클라우드 RL 학습 (PPO, SAC, DDPG, TD3)
고급 센서 - 열화상, 밀리미터파(MMWave), 가스, 음향, 자기 센서
비전 및 접지(Grounding) - 오픈 어휘 객체 탐지
촉각 센싱 - ORCA Hand 576-taxel 피드백
모션 계획 - 충돌 회피 기능이 포함된 MoveIt2 통합
작업 계획 - 행동 트리를 사용한 계층적 작업 실행
ROS2 통합 - 실제 로봇(UR5e, Panda, Spot)을 위한 클라우드 브리지
안전 모니터링 - 실시간 안전 검증 및 비상 정지
MQTT IoT - 엣지 컴퓨팅을 통한 1000개 이상의 에이전트 지원
자율 에이전트 - 자체 등록 및 ETH 기반 결제
Related MCP server: SO-ARM100 Robot Control MCP
git clone https://github.com/RedCiprianPater/mcp-server-robotics.git
cd mcp-server-roboticsnpm installcp .env.example .env
# Edit .env and add your NWO_API_KEY
nano .envnpm run build
npm start# The server will start and display available tools
# You can now use any of the 77 tools through Claudesrc/index.ts - 전체 MCP 서버 구현 (77개 도구)
package.json - 의존성 및 빌드 스크립트
tsconfig.json - TypeScript 설정
Dockerfile - 컨테이너 배포
docker-compose.yml - MQTT 브로커를 포함한 전체 스택
.env.example - 환경 변수 템플릿
INTEGRATION_GUIDE.md - 상세 통합 지침
README.md - 이 파일
✅ 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 executionInference & 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)https://nwo.capital/webapp/api-key.php 에서 무료 API 키를 받으세요.
export NWO_API_KEY="sk_live_your_key_here"# Standard API (full features)
NWO_API_BASE=https://nwo.capital/webapp/api-key.php
# 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
}}]
});작업 | 지연 시간 | 비고 |
표준 추론 | 100-120ms | EU 데이터센터 |
엣지 추론 | 25-50ms | 전 세계 200개 이상의 위치 |
SLAM 초기화 | 200-500ms | 이미지 품질에 따라 다름 |
SLAM 위치 추정 | 100-300ms | 기존 맵 내 |
RL 학습 (단계당) | 50-100ms | MuJoCo 시뮬레이션 |
작업 계획 | 500-1000ms | 복합 분해 |
센서 퓨전 | 150-300ms | 다중 센서 처리 |
비상 정지 | <10ms | 응답 보장 |
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)무료 티어: 월 100,000회 호출
프로토타입: 월 500,000회 호출 (일 약 16,666회)
프로덕션: 무제한 호출
사용량 모니터링:
const balance = await client.messages.create({
tools: [{name: "nwo_agent_check_balance", input: {
agent_id: "agent_123"
}}]
});실시간 충돌 감지
인간 근접 경고 (기본 1.5m)
비상 정지 (<10ms 응답)
힘/토크 제한 적용
규정 준수를 위한 감사 로그
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_fusionGitHub: https://github.com/RedCiprianPater/mcp-server-robotics
백서: https://www.researchgate.net/publication/401902987_NWO_Robotics_API_WHITEPAPER
데모: https://huggingface.co/spaces/PUBLICAE/nwo-robotics-api-demo
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)✅ 설정: npm install && npm run build
✅ 구성: .env에 NWO_API_KEY 추가
✅ 테스트: npm start 후 도구 로드 확인
✅ 통합: Claude API 또는 프레임워크와 함께 사용
✅ 배포: Docker Compose 또는 Kubernetes
✅ 모니터링: 로그 및 사용량 지표 확인
✅ 확장: 필요에 따라 티어 업그레이드
이슈: https://github.com/RedCiprianPater/mcp-server-robotics/issues
토론: https://github.com/RedCiprianPater/mcp-server-robotics/discussions
API 키 도움말: https://nwo.capital/webapp/api-key.php
✅ 총 77개 도구 구현
✅ 우선순위 1: SLAM, RL, Grounding (5)
✅ 우선순위 2: 고급 센서 (5)
✅ 우선순위 3: 고급 기능 (4)
✅ 표준 작업 (58)
✅ 완전한 TypeScript 지원
✅ Docker 및 Kubernetes 준비 완료
✅ 프로덕션급 오류 처리
✅ 전체 테스트 커버리지
기본 도구 세트 (20개 도구)
표준 추론 전용
수동 설정
MIT 라이선스 - 자세한 내용은 LICENSE 파일을 참조하세요.
NWO 로보틱스 - API 및 인프라
Anthropic - Claude 및 MCP 프로토콜
오픈 소스 커뮤니티 - 기여 및 피드백
마지막 업데이트: 2026년 4월 상태: ✅ 프로덕션 준비 완료 관리자: @RedCiprianPater
Check API quota usage and tier status
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'checking' API quota usage and tier status, which implies a read-only operation, but doesn't specify permissions, rate limits, or response format, leaving gaps in behavioral understanding.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's purpose with zero waste. It is appropriately sized and front-loaded, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is adequate but minimal. It covers the basic purpose but lacks details on behavioral traits or usage context, making it just sufficient for a simple read operation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so no parameter information is needed. The description appropriately focuses on the tool's purpose without redundant parameter details, earning a high baseline score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with specific verbs ('check') and resources ('API quota usage and tier status'), making it easy to understand what the tool does. However, it doesn't differentiate from sibling tools, which are unrelated to API quota management (e.g., detect_objects, execute_robot_task), so it doesn't fully distinguish itself in context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The description lacks context about prerequisites, timing, or comparisons with other tools, leaving the agent without explicit usage instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Run computer vision to detect objects
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | What to look for (e.g., "red boxes", "people") | |
| camera_id | No | Camera to use (optional) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool performs computer vision detection but doesn't describe what happens during execution (e.g., processing time, resource usage, error conditions, or output format). This is a significant gap for a tool with no annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste. It's front-loaded and appropriately sized for the tool's complexity, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., bounding boxes, confidence scores) or behavioral aspects like performance or limitations. For a computer vision tool with two parameters, this leaves critical gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters thoroughly. The description adds no additional meaning beyond what the schema provides (e.g., it doesn't explain how 'query' interacts with detection or clarify 'camera_id' usage). Baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Run computer vision') and the purpose ('to detect objects'), providing a specific verb+resource combination. However, it doesn't differentiate this tool from potential sibling computer vision tools (none are listed among siblings, so this is less critical).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context, or exclusions, leaving the agent to infer usage from the tool name and parameters alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Send a Vision-Language-Action command to a robot
| Name | Required | Description | Default |
|---|---|---|---|
| robot_id | Yes | ID of the robot to control | |
| instruction | Yes | Natural language instruction (e.g., "Move to loading dock") | |
| coordinates | No | Optional target coordinates |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'Vision-Language-Action command' but doesn't explain what that entails (e.g., is it a complex AI-driven task, does it involve movement or sensing, are there safety or permission requirements?). This leaves critical behavioral traits unspecified for a robot control tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste—it directly states the tool's function without unnecessary words, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the complexity of robot control (a potentially high-stakes operation), no annotations, no output schema, and the description's lack of behavioral details, it's incomplete. The agent lacks information on what happens after execution (e.g., success/failure, response format) or any constraints, making this inadequate for safe and effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters (robot_id, instruction, coordinates). The description adds no additional meaning beyond what's in the schema, such as examples of valid instructions or coordinate usage, resulting in the baseline score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Send a Vision-Language-Action command') and the target ('to a robot'), making the purpose understandable. However, it doesn't differentiate this tool from potential siblings like 'stop_robot' or 'get_robot_status' that also involve robot interaction, missing explicit distinction.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. For example, it doesn't specify if this is for high-level commands versus direct control, or how it differs from 'stop_robot' or 'get_robot_status', leaving the agent without context for selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get information about the current agent account
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but only states it 'gets information,' implying a read-only operation without details on permissions, rate limits, or what specific data is returned. It lacks behavioral context like whether it requires authentication or what happens on failure.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with no wasted words, clearly front-loading the purpose. It's appropriately sized for a simple, no-parameter tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description is incomplete: it doesn't explain what information is returned (e.g., account details, status) or behavioral aspects. For a tool in a context with siblings like 'get_robot_status', more detail on output would help distinguish it.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add param info, but this is acceptable given the schema's completeness, aligning with the baseline for zero parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Get information') and resource ('about the current agent account'), making the purpose understandable. However, it doesn't differentiate from siblings like 'get_robot_status' or 'register_agent' in terms of what specific information is retrieved versus those other tools.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context (e.g., after registration), or exclusions, leaving the agent to infer usage from the name alone among siblings like 'check_balance' or 'query_sensors'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get status of all connected robots
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It mentions retrieving status but doesn't specify whether this is a read-only operation, what permissions are required, how frequently it can be called, or what format the status information returns. This leaves significant gaps for a tool that interacts with connected hardware.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence that directly states the tool's function without unnecessary words. It's perfectly front-loaded and every word earns its place, making it easy to parse quickly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool that retrieves status from connected robots (potentially complex hardware interactions), the description is inadequate. With no annotations, no output schema, and minimal behavioral context, it doesn't provide enough information about what 'status' includes, how results are structured, or important operational constraints.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so the schema already fully documents the absence of inputs. The description appropriately doesn't waste space discussing parameters, maintaining focus on the tool's purpose. A baseline of 4 is appropriate for zero-parameter tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Get') and resource ('status of all connected robots'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'get_agent_info' or 'query_sensors' that might also retrieve status-related information, preventing a perfect score.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives like 'get_agent_info' or 'query_sensors', nor does it mention prerequisites or context for usage. It simply states what the tool does without indicating appropriate scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Query IoT sensors by location
| Name | Required | Description | Default |
|---|---|---|---|
| location | Yes | Location to query (e.g., "warehouse_1") | |
| sensor_type | No | Type of sensor (temperature, humidity, motion, etc.) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool queries sensors, implying a read operation, but doesn't disclose critical behavioral traits such as whether it requires authentication, has rate limits, returns real-time or historical data, or what format the results take. For a query tool with zero annotation coverage, this leaves significant gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero waste. It's appropriately sized and front-loaded, clearly stating the tool's purpose without unnecessary elaboration. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the lack of annotations and output schema, the description is incomplete for a query tool. It doesn't explain what the tool returns (e.g., sensor readings, metadata, or a list of sensors), potential error conditions, or behavioral constraints. For a tool that interacts with IoT sensors—which may involve real-time data, permissions, or rate limits—this is inadequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with both parameters clearly documented in the input schema. The description adds minimal value beyond the schema by implying location-based filtering, but doesn't provide additional syntax, format details, or examples. This meets the baseline score of 3 when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('query') and resource ('IoT sensors'), and specifies the query dimension ('by location'). However, it doesn't differentiate this tool from potential sibling tools that might also query sensors, though none of the listed siblings appear to be direct alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, exclusions, or compare it to other tools that might query sensors differently (e.g., by time range or sensor ID). With no explicit usage context, the agent must infer when this tool is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Self-register as a new AI agent (if not already registered)
| Name | Required | Description | Default |
|---|---|---|---|
| wallet_address | Yes | Ethereum wallet address (0x...) | |
| agent_name | Yes | Name for this agent | |
| capabilities | No | List of capabilities (vision, navigation, manipulation, iot) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. While it mentions the idempotent nature ('if not already registered'), it doesn't address important behavioral aspects like authentication requirements, rate limits, what happens upon successful registration, or potential error conditions. The description is too minimal for a mutation tool with no annotation support.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise - a single sentence with a clarifying parenthetical. Every word serves a purpose, and the core functionality is communicated upfront without unnecessary elaboration. This is an excellent example of efficient communication.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with no annotations and no output schema, the description is insufficiently complete. It doesn't explain what happens after registration, what the expected outcomes are, or what capabilities registration enables. Given that this appears to be a system setup tool with blockchain integration (wallet address), more context about the registration process and its implications would be helpful.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema description coverage is 100%, with all parameters well-documented in the schema itself. The description doesn't add any additional parameter information beyond what's already in the schema, so it meets the baseline expectation but doesn't provide extra value. The description doesn't explain relationships between parameters or provide usage examples.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Self-register') and the resource ('as a new AI agent'), with the parenthetical '(if not already registered)' adding useful context about idempotent behavior. However, it doesn't specifically differentiate this tool from its sibling tools like 'get_agent_info' - both relate to agent information but serve different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use this tool ('if not already registered'), suggesting it should be used for initial setup or when an agent needs to register itself. However, it doesn't provide explicit guidance about when NOT to use it or mention alternatives like 'get_agent_info' for checking registration status.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Emergency stop a robot
| Name | Required | Description | Default |
|---|---|---|---|
| robot_id | Yes | ID of the robot to stop |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. It implies a destructive action ('stop') but doesn't clarify critical aspects like whether this is irreversible, requires specific permissions, has safety implications, or what happens post-stop (e.g., robot state). The term 'Emergency' hints at urgency but lacks operational details.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core action and resource, making it immediately scannable and appropriately sized for a simple tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's potential complexity (emergency stop implies safety-critical operations) and lack of annotations or output schema, the description is insufficient. It doesn't address behavioral risks, response format, or error conditions, leaving significant gaps for an agent to use it safely and effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with the single parameter 'robot_id' documented in the schema. The description adds no additional parameter semantics beyond implying the tool acts on a robot, which is already clear from the schema. This meets the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Emergency stop') and target resource ('a robot'), making the purpose immediately understandable. It doesn't differentiate from sibling tools like 'execute_robot_task' or 'get_robot_status', but the verb 'stop' is specific enough to convey the core function.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, conditions for emergency use, or contrast with other robot-related tools like 'execute_robot_task' or 'get_robot_status', leaving the agent to infer usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v1.0.0check_balancedetect_objectsexecute_robot_taskget_agent_infoget_robot_statusquery_sensorsregister_agentstop_robotScored across 8 tools
Each tool has a clearly distinct purpose with no ambiguity: checking API balance, object detection, robot task execution, agent info retrieval, robot status monitoring, sensor querying, agent registration, and emergency robot stop. The descriptions clearly differentiate their functions, making misselection unlikely.
Most tools follow a consistent verb_noun pattern (e.g., check_balance, detect_objects, get_agent_info, get_robot_status, query_sensors, register_agent, stop_robot), but 'execute_robot_task' slightly deviates with a verb_verb_noun structure. Overall, the naming is highly readable and predictable.
With 8 tools, this server is well-scoped for robotics and IoT management. Each tool earns its place by covering distinct aspects like vision, robot control, agent management, and sensor monitoring, without feeling bloated or sparse.
The toolset provides strong coverage for core robotics workflows, including robot control (execute, stop, status), vision (detect), agent management (register, info), and sensor integration (query). Minor gaps might include updating robot tasks or managing sensor configurations, but agents can work around these.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Give your AI hands. Identity, credential vault, and API gateway for autonomous agents.
The cloud for agents. Tools for AI agents to register, build, and deploy other agents. Zero human required.
AI agent gateway with web fetching, data extraction, crypto pricing, and x402 payments
AI service marketplace — agents discover, call, and pay for API services automatically.