OttO Core

OttO Core is a lightweight Rust server that runs as a system daemon. It stores your knowledge graph in a local vector database and exposes two endpoints:

• http://localhost:47821/api — REST API for reading and writing knowledge nodes
• http://localhost:47821/mcp — Model Context Protocol server for AI assistant integrations

Your data never leaves your machine. The daemon starts automatically on boot and restarts if it crashes.

Since v0.2.0 the server also listens on your local network so OttO Mobile can connect. Requests from other devices must present a pairing token — requests from the machine itself are unaffected.

Download the installer for your platform from the Download page. OttO Core runs as a system service and starts automatically on boot.

Download otto-core-macos-arm64.pkg from the download page, double-click it, follow the installer wizard and enter your password. The server starts immediately as a LaunchDaemon. No reboot required.

Verify it is running:

Download otto-core-windows-x86_64.exe, right-click it and select Run as Administrator, then follow the setup wizard. The server is registered as a Windows Service and starts automatically on boot.

Verify it is running:

To manage the service: open Services and look for OttO Core.

Download the binary and the install script, place them in the same directory, then run:

The installer registers a systemd service that starts on boot. Check status:

Coming soon.

OttO Core exposes a Model Context Protocol (MCP) server at http://localhost:47821/mcp. Any MCP-compatible AI assistant can connect to it and use OttO's tools to read from and write to your knowledge graph.

Add OttO Core to your MCP client of choice using the configurations below. The server URL is always http://localhost:47821/mcp.

Add the following to your .mcp.json (project root) or ~/.claude/mcp.json (global):

{
  "mcpServers": {
    "otto": {
      "type": "http",
      "url": "http://localhost:47821/mcp"
    }
  }
}

Claude Code detects the config automatically and connects on the next session start.

Open Antigravity AI settings, navigate to MCP Servers, and add a new server with the following config:

{
  "mcpServers": {
    "otto": {
      "type": "http",
      "url": "http://localhost:47821/mcp"
    }
  }
}

After saving, OttO tools appear in the Antigravity tool picker.

Add the following to ~/.cursor/mcp.json (global) or .cursor/mcp.json in your project:

{
  "mcpServers": {
    "otto": {
      "type": "http",
      "url": "http://localhost:47821/mcp"
    }
  }
}

Restart Cursor after saving. OttO tools will be available in Cursor Agent mode.

Paste the snippet below into your CLAUDE.md (project root) or ~/.claude/CLAUDE.md (global) to make Claude automatically use OttO in every session. Works the same way in CURSOR.md for Cursor.

# Tasks for Every Request

Use only English

Actively use the OttO MCP tools (locate, spread_search_context, search_plans, save_inference, save_plan, add_knowledge). All usage guidance is in the MCP server instructions. For non-trivial tasks, save key findings with save_inference or save_plan.

Once connected, OttO exposes the following tools to your AI assistant. The assistant calls them automatically based on context you don't need to invoke them manually.

add_knowledge({ "text": "Transformers use self-attention to model long-range dependencies." })

spread_search_context({ "query": "attention mechanisms in neural networks" })

search_inferences({ "query": "how to handle rate limits" })

save_inference({ "problem": "API rate limits", "solution": "Implement exponential backoff with jitter." })

OttO Core exposes a JSON REST API at http://localhost:47821/api. You can use it to integrate OttO into any script, application, or workflow that can make HTTP requests. No MCP client required.

All request bodies are JSON. All responses are JSON. Requests from the machine itself need no authentication. Requests from other devices on your network (such as OttO Mobile) must send the pairing token:

Authorization: Bearer <pairing-token>

The projects endpoints manage isolated knowledge graph workspaces. Each project stores its own nodes, connections, and vector database independently.

Storage layout

projects/
  manifest.json          # project list + active project ID
  {project_id}/
    vectordb.bin         # knowledge graph for that project

On first run, if a root-level vectordb.bin exists, it is automatically migrated into a project named Default.

The knowledge endpoints let you add and retrieve nodes in the graph. Each node is a piece of text the server handles chunking, embedding, and linking automatically.

Add a node

POST /api/knowledge
Content-Type: application/json

{
  "text": "The mitochondria is the powerhouse of the cell."
}

Returns the created node ID and the number of chunks stored.

Response

{
  "id": "node_abc123",
  "chunks": 1
}

Semantic search finds knowledge by meaning, not exact keywords. The server embeds the query and compares it against all stored embeddings using cosine similarity.

Search

GET /api/search?q=attention+mechanisms&limit=5

limit is optional (default: 10). Returns results sorted by relevance score descending.

Response

{
  "results": [
    {
      "id": "node_abc123",
      "text": "Transformers use self-attention to model long-range dependencies.",
      "score": 0.94
    },
    {
      "id": "node_def456",
      "text": "The attention mechanism computes a weighted sum of value vectors.",
      "score": 0.87
    }
  ]
}

Inferences are a special class of knowledge nodes they store solutions, decisions, and findings so they can be recalled in future sessions. Saving an inference is equivalent to calling save_inference via MCP.

Save an inference

POST /api/inferences
Content-Type: application/json

{
  "problem": "API rate limits causing 429 errors under load",
  "solution": "Implement exponential backoff with jitter. Start at 1 s, cap at 60 s."
}

Search inferences

GET /api/inferences/search?q=rate+limits

{
  "results": [
    {
      "problem": "API rate limits causing 429 errors under load",
      "solution": "Implement exponential backoff with jitter. Start at 1 s, cap at 60 s.",
      "score": 0.96
    }
  ]
}

The task queue is shared between the desktop app, OttO Mobile, and AI assistants connected via MCP. Every change is broadcast on the event stream so all clients stay in sync.

These endpoints power the OttO Mobile companion app.

Run the commands below to completely remove OttO Core from your system. The macOS commands also clean up leftovers from older releases.

If you remove the hook file, also delete its otto-session-reminder entries from the SessionStart section of ~/.claude/settings.json.

Run as Administrator in Command Prompt.