MCPolly

by MCPolly

2 130 downloads Not rated yet

GitHub

Developer Tools

About

Agent-native observability for AI agents. MCP server with web dashboard, alerting, and semantic search. Built with Rust, Axum, SQLite, and HTMX.

Explore

- Agent registration and real‑time status tracking (starting, running, error, completed, etc.)
- Real‑time activity feed and global error feed across all agents
- Configurable webhook alerts (Discord, Slack, generic) with retry logic
- Dark‑mode web dashboard with live updates via HTMX polling
- Vector semantic search over indexed documents using local Ollama embeddings
- Agent spawning with contextual knowledge from indexed content

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name MCPolly

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "mcpolly": {
            "mcpolly": {
                "url": "http://localhost:3000/mcp",
                "headers": {
                    "Authorization": "Bearer your-api-key-here"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcpolly": {
            "mcpolly": {
                "url": "http://localhost:3000/mcp",
                "headers": {
                    "Authorization": "Bearer your-api-key-here"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcpolly": {
            "mcpolly": {
                "url": "http://localhost:3000/mcp",
                "headers": {
                    "Authorization": "Bearer your-api-key-here"
                }
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "mcpolly": {
            "mcpolly": {
                "url": "http://localhost:3000/mcp",
                "headers": {
                    "Authorization": "Bearer your-api-key-here"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcpolly": {
            "mcpolly": {
                "url": "http://localhost:3000/mcp",
                "headers": {
                    "Authorization": "Bearer your-api-key-here"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcpolly": {
            "mcpolly": {
                "url": "http://localhost:3000/mcp",
                "headers": {
                    "Authorization": "Bearer your-api-key-here"
                }
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "mcpolly": {
            "mcpolly": {
                "url": "http://localhost:3000/mcp",
                "headers": {
                    "Authorization": "Bearer your-api-key-here"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcpolly": {
            "mcpolly": {
                "url": "http://localhost:3000/mcp",
                "headers": {
                    "Authorization": "Bearer your-api-key-here"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcpolly": {
            "mcpolly": {
                "url": "http://localhost:3000/mcp",
                "headers": {
                    "Authorization": "Bearer your-api-key-here"
                }
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "mcpolly": {
            "mcpolly": {
                "url": "http://localhost:3000/mcp",
                "headers": {
                    "Authorization": "Bearer your-api-key-here"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcpolly": {
            "mcpolly": {
                "url": "http://localhost:3000/mcp",
                "headers": {
                    "Authorization": "Bearer your-api-key-here"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcpolly": {
            "mcpolly": {
                "url": "http://localhost:3000/mcp",
                "headers": {
                    "Authorization": "Bearer your-api-key-here"
                }
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "mcpolly": {
            "mcpolly": {
                "url": "http://localhost:3000/mcp",
                "headers": {
                    "Authorization": "Bearer your-api-key-here"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcpolly": {
            "mcpolly": {
                "url": "http://localhost:3000/mcp",
                "headers": {
                    "Authorization": "Bearer your-api-key-here"
                }
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "mcpolly": {
            "mcpolly": {
                "url": "http://localhost:3000/mcp",
                "headers": {
                    "Authorization": "Bearer your-api-key-here"
                }
            }
        }
    }
}

From the repository

- Ollama installed and running with all-minilm model pulled (for embeddings)
- Port 3000 (or configured port) available

Detects your OS and architecture, downloads the correct binaries from GitHub Releases:

curl -fsSL https://raw.githubusercontent.com/MCPolly/mcpolly/main/install.sh | bash

Customize with environment variables:

MCPOLLY_BINARY=mcp curl -fsSL https://raw.githubusercontent.com/MCPolly/mcpolly/main/install.sh | bash MCPOLLY_INSTALL_DIR=/usr/local/bin curl -fsSL https://raw.githubusercontent.com/MCPolly/mcpolly/main/install.sh | bash

MCPOLLY_VERSION=v0.2.0 curl -fsSL https://raw.githubusercontent.com/MCPolly/mcpolly/main/install.sh | bash

Supported platforms: Linux (x86_64, aarch64, armv7), macOS (x86_64, Apple Silicon), Windows (x86_64).

cargo install mcpolly --bin mcpolly_mcp

curl -fsSL https://ollama.ai/install.sh | sh Add MCPolly to your AI agent platform's MCP configuration. To have every Claude Code session — across all projects — automatically register and report status to MCPolly, configure both the MCP server and agent instructions globally. Step 1: Add MCPolly as a global MCP server

bash
claude mcp add mcpolly --transport http http://localhost:3000/mcp \
--header "Authorization: Bearer your-api-key-here"

This makes the MCPolly MCP tools available in every Claude Code session without per-project .mcp.json files. Step 2: Auto-approve MCPolly tools globally Edit ~/.claude/settings.json (create it if it doesn't exist):

json
{
"permissions": {
"allow": [
"mcp__mcpolly__*"
]
}
}

This prevents Claude Code from prompting for permission each time it calls a MCPolly tool. Step 3: Add agent instructions to your global CLAUDE.md Append the contents of GLOBAL_CLAUDE.md to ~/.claude/CLAUDE.md (create it if it doesn't exist):

bash
cat /path/to/mcpolly/GLOBAL_CLAUDE.md >> ~/.claude/CLAUDE.md

Or manually add:

markdown

MCPolly is designed to run on minimal hardware. A $4/month VPS is sufficient.

Once configured, the following MCP tools are available to AI agents:

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "mcpolly": {
            "mcpolly": {
                "url": "http://localhost:3000/mcp",
                "headers": {
                    "Authorization": "Bearer your-api-key-here"
                }
            }
        }
    }
}

McpServers

{
    "mcpolly": {
        "url": "http://localhost:3000/mcp",
        "headers": {
            "Authorization": "Bearer your-api-key-here"
        }
    }
}

Agent-native status, observability, and knowledge platform for AI agents. MCPolly is an MCP server that lets AI agents report their progress, errors, and state in real time — and gives humans a unified web dashboard to monitor everything. Agents can also index and semantically search product documents to stay aligned.

Built with Rust, Axum, SQLite, and HTMX. Designed to self-host on minimal hardware.

Architecture

┌─────────────────┐   MCP Streamable HTTP   ┌──────────────────┐
│  AI Agent       │◄───────────────────────►│  MCPolly Server  │
│  (Cursor, etc.) │   JSON-RPC / SSE        │  (Axum + SQLite) │
└─────────────────┘   Bearer auth           └──────┬───────────┘
                                                   │
                                          ┌────────▼────────┐
                                          │   Web Dashboard  │
                                          │   (HTMX UI)      │
                                          └─────────────────┘
                                                   │
                                          ┌────────▼────────┐
                                          │  Ollama (local)  │
                                          │  all-MiniLM      │
                                          └─────────────────┘

MCPolly exposes a /mcp endpoint that speaks the MCP Streamable HTTP protocol (JSON-RPC over HTTP with SSE streaming). Agent platforms connect directly — no subprocess binary needed.

- MCPolly Server — The Axum HTTP server that stores agent data in SQLite, serves the web UI, evaluates alert rules, manages vector embeddings, and hosts the MCP endpoint.
- Ollama — Local LLM server used for generating vector embeddings with the all-MiniLM model (384 dimensions).
- mcpolly_mcp (optional) — A lightweight stdio binary for platforms that don't support HTTP MCP transport. It bridges stdio to the MCPolly HTTP API.

Features

Agent Observability

- Agent registration and status tracking (starting, running, warning, error, completed, offline, paused, errored, stopping, stopped) - Real-time activity feed with color-coded entries - Global error feed across all agents - Webhook alerts (Discord, Slack, generic) with retry logic - Configurable alerts for any status change — error, completed, running, starting, warning, paused, stopped, offline, or a catch-all "any status" rule - Silent agent detection (background checker)

Web Dashboard

- Dark mode with system preference detection - First-run setup wizard with auto-login and MCP configuration snippets - Instance reset from the login page (revokes all keys, generates a new one, re-enters setup wizard) - Health strip summary (total/running/errored/offline agent counts) - Status filter pills for quick agent filtering - Agent detail page with tabbed content (Activity, Errors, Info) - Global command bar (Cmd+K) searching agents, errors, and knowledge - Alert rules management with notification history - Knowledge page with semantic search UI - API key management - Settings page with server info and session management - 10-second HTMX polling for live updates

Knowledge Layer (Vector Embeddings)

- Index PRD, design, and custom documents as vector embeddings - Semantic search across all indexed content via MCP tools and web UI - Spawn product manager and product designer agents with relevant context - Powered by sqlite-vec (in-process) and Ollama (local, no cloud API keys needed)

Installation

Option 1: Install Script (recommended)

Detects your OS and architecture, downloads the correct binaries from GitHub Releases:

curl -fsSL https://raw.githubusercontent.com/MCPolly/mcpolly/main/install.sh | bash

Customize with environment variables:

```bash

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Explore

Setting up with Highlight

From the repository

Claude Desktop / Cursor

McpServers

Architecture

Features

Agent Observability

Web Dashboard

Knowledge Layer (Vector Embeddings)

Installation

Option 1: Install Script (recommended)

More like this

Sentry

Github

Git

GitLab