MCP tools

Browse, invoke, and extend Jarvis’s 526+ Model Context Protocol tools — from ServiceNow integrations to custom automation.

Model Context Protocol (MCP) tools are the actions your agents can take. Every tool is a discrete capability — querying a database, filing a ticket, reading a file, calling an API — that agents discover and invoke at runtime based on the task at hand.

Jarvis ships with 526+ tools out of the box, and you can add your own.

Agent overview

Learn how agents select and invoke tools during a task.

API tools endpoint

Query available tools programmatically via the REST API.

What MCP tools are

MCP is an open protocol that standardizes how AI agents communicate with external systems. Each tool has a name, a description, and a typed input schema. When an agent receives a task, it inspects the available tools, selects the ones it needs, and calls them — passing structured arguments and receiving structured results.

You don’t invoke tools manually in most cases. Agents handle tool selection automatically. But you can browse available tools, invoke them directly through the API, and register new ones.

Available tools

ServiceNow (526 tools)

The ServiceNow integration covers the full ServiceNow API surface. Your agents can:

• Create, update, and resolve incidents, changes, and problems
• Query configuration items (CIs) from the CMDB
• Manage users, groups, and roles
• Trigger workflows and approval chains
• Read and write knowledge base articles

All 526 tools follow the naming convention servicenow.<resource>.<action> — for example, servicenow.incident.create or servicenow.cmdb.query.

Custom Jarvis tools

Jarvis ships with tools built specifically for homelab and infrastructure management:

Tool	What it does
jarvis.mesh.status	Returns the health and load of all brain mesh nodes
jarvis.mesh.route	Routes a task to the best available node
jarvis.model.list	Lists all available models and their current status
jarvis.model.invoke	Runs inference on a specific model directly
jarvis.workflow.trigger	Triggers an n8n workflow by name or ID
jarvis.memory.search	Queries the RAG memory system across all layers
jarvis.memory.store	Writes a fact or document to persistent memory

Custom tools live in the jarvis.* namespace to avoid collisions with external integrations.

Infrastructure and operations

These tools let agents interact with your infrastructure directly:

• Docker — list containers, inspect logs, start/stop services
• SSH — run shell commands on mesh nodes
• File system — read, write, and search files on connected hosts
• Monitoring — query metrics, read alerts, and acknowledge incidents

Browse available tools

You can list all registered tools through the API:

curl https://your-jarvis-host/api/tools

To filter by namespace:

curl "https://your-jarvis-host/api/tools?namespace=servicenow"

Each tool entry includes its name, description, and input schema — the same information your agents use to decide which tool to call.

Invoke a tool directly

You can call any tool without going through an agent:

curl -X POST https://your-jarvis-host/api/tools/invoke \
  -H "Content-Type: application/json" \
  -d '{
    "tool": "servicenow.incident.create",
    "input": {
      "short_description": "Disk usage above 90% on jarvis-brain",
      "urgency": 2,
      "category": "infrastructure"
    }
  }'

The response contains the tool’s output, the execution time, and any errors:

{
  "result": {
    "sys_id": "abc123",
    "number": "INC0045231",
    "state": "1"
  },
  "duration_ms": 340,
  "error": null
}

How agents use tools

When you give an agent a task, it:

1. Receives the full list of tools registered in Jarvis
2. Reads each tool’s name and description to understand what’s available
3. Selects the tools relevant to the task
4. Calls them in sequence or parallel, depending on dependencies
5. Feeds the results back into its reasoning to decide what to do next

Agents do this autonomously. You don’t need to specify which tools to use — just describe the task.

You can steer tool selection by being specific in your prompt. “File a ServiceNow incident” will push the agent toward servicenow.incident.create rather than a generic notification tool.

Add custom MCP tools

You can register your own tools alongside the built-in ones. Each tool needs:

• A unique name (use a namespace prefix to avoid collisions)
• A description the agent can read and understand
• A JSON Schema defining the input parameters
• A handler: an HTTP endpoint, a shell command, or an n8n workflow

1. Define the tool

   Create a tool definition file:

   {
     "name": "myteam.deploy.service",
     "description": "Deploys a Docker service to the specified mesh node.",
     "inputSchema": {
       "type": "object",
       "properties": {
         "service": { "type": "string", "description": "Docker Compose service name" },
         "node": { "type": "string", "description": "Target mesh node hostname" }
       },
       "required": ["service", "node"]
     },
     "handler": {
       "type": "http",
       "url": "https://your-jarvis-host:8080/deploy",
       "method": "POST"
     }
   }
   
2. Register the tool

   POST the definition to the tools API:

   curl -X POST https://your-jarvis-host/api/tools \
     -H "Content-Type: application/json" \
     -d @myteam.deploy.service.json
   
3. Verify registration

   Confirm the tool appears in the tool list:

   curl "https://your-jarvis-host/api/tools?namespace=myteam"
   

   Your agents can now discover and invoke the new tool.

Tool descriptions matter. Agents use them to decide whether a tool fits the task. Write descriptions that clearly explain what the tool does and when to use it — not how it works internally.