silo MCP server
Commit Nov 12, 2026An agent-native personal link store that captures web material with rich metadata and serves it to AI agents via MCP.
Also known as amitray007/silo
- Stars
- 1
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Nov 12, 2026
- License
- MIT
What is silo MCP?
silo is an agent-native personal link store that captures web material with rich metadata and serves it to AI agents via MCP.
Summary generated from the project's README
About silo MCP server
Storing and organizing web content for AI agents is what silo enables. This personal link store captures URLs, social media posts, and videos, enriching them with full text and rich metadata like YouTube thumbnails or GitHub star counts. It is designed for single users who want a private, self-hosted substrate where an external AI agent provides the intelligence rather than the server itself.
Developers can connect agents using three distinct methods: a local subprocess via stdio for tools like Claude Desktop, a remote HTTP connection using a bearer token, or a URL-only OAuth connector for hosted services like ChatGPT. The system requires Node 24+, pnpm 10+, and a Postgres database with the pgvector extension. While it includes a web UI for human management, the core logic is shared with 18 MCP tools, ensuring that what an agent sees is identical to what a human sees in the browser.
Users can manage their library through specific commands like capture_link, search_links, and add_link_tag. The system also handles background maintenance, such as purging old items from the trash and re-enqueuing failed captures.
What you can do with it
- 1Automated web content captureAn agent can save a specific URL and have the system automatically extract the full text and metadata.
- 2Semantic link searchingA developer can ask an AI to find specific information buried within previously saved articles or notes.
- 3Organizing research with tagsAn AI agent can categorize saved links by applying specific tags to keep a research library organized.
- 4Retrieving source-specific dataAn agent can access specialized details for technical or social media links like GitHub stars or YouTube channels.
Written from the project's README. Every use case is checked against a quote from it.
Configuration
DATABASE_URL
Automated checks
Ran Nov 15, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachableamitray007/silo is public and reachablegithub.com/amitray007/silo ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-12github.com/amitray007/silo ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubsilo
An agent-native personal link store.
Feed in web material — links, Twitter/X posts, HN posts, videos — captured with rich metadata and full text, organized by tags and one note field, searchable, and served over MCP so an external agent does the intelligence.
AI is optional. silo is the substrate; the mind sits on top, over MCP. You can turn on small AI features, such as short titles for saved X posts, with your own Anthropic, OpenAI, or Vercel AI Gateway key. They are off by default, and silo works fully without them.
brew install amitray007/tap/silo
What it does
- Capture a URL → silo canonicalizes and dedups it, then a background worker fetches it (SSRF-safe), extracts a readable card (title, description, site, image, full text via Readability), and files it.
- Search & browse — full-text search across title, description, extracted text, notes, and tags; open one link's full detail; browse newest-first, filtered by tag or capture status; all paginated.
- Organize — edit the note, add/remove tags (case-insensitive), trash and restore, and retry a degraded capture.
- Rich per-source previews — Hacker News, GitHub, and YouTube links get source-specific data (points/comments, stars/forks/language, channel/thumbnail) via a small plugin registry; each source is togglable in Settings.
- Runs itself — scheduled jobs purge old trash on a cycle, re-enqueue any capture stranded mid-enrichment, and alert on the dead-letter queue.
- Two front doors, one core — everything an agent can do over MCP, a human can do in the web UI over HTTP. Both call one core, so they can never drift.
It's single-user, self-hosted, and private. Deliberately not a file store, not a content archive, not multi-user — and it never summarizes or classifies on its own. That's the agent's job.
Screenshots
The web UI (@silo/web, React + Vite in the "Oat" design system) in light and dark.
How it works
One core holds every operation; thin adapters expose it. Anything an agent can do over MCP, a human can do in the web UI — they call the same core, so the two views never drift.
agent ──MCP──┐ ┌── stdio (local subprocess)
├──▶ core ◀──────┤── HTTP + token
human ──HTTP─┘ (the brain) └── HTTP + OAuth (Claude / ChatGPT connectors)
│
background worker ── enrich · purge · sweep · retry
An agent operates silo through 18 MCP tools:
capture_link · get_link · search_links · list_links · edit_link · create_tag ·
add_link_tag · remove_link_tag · delete_tag · trash_link · restore_link · retry_capture ·
export_links · find_related · refresh_reader · list_tags · list_trash · hard_delete_link
A background worker runs alongside: it enriches new captures, purges old trash on a cycle (7 / 30 / 90 days), re-enqueues anything stranded mid-enrichment, and watches the dead-letter queue. Theme, purge cycle, and per-source plugin toggles are stored server-side.
Full scope map and anti-scope: docs/product/scope.html.
Getting started
You need Node 24+, pnpm 10+, and Postgres with the pgvector extension (Docker gives you
that in one command).
pnpm install # deps + git hooks
pnpm db:up # Postgres (pgvector) via Docker, waits for health
cp .env.example .env # DATABASE_URL — defaults already match db:up
pnpm db:migrate # apply the schema
Now run one of two ways, depending on who's using it:
pnpm dev # for a human: API + web UI + worker → open http://localhost:5173
pnpm start # for an agent: the MCP server (stdio) + worker, no web UI
pnpm devserves the React web UI (Vite proxies/api/*to the API, so it's same-origin — no CORS). The API binds to loopback with no auth; it's a single-user localhost surface. Renders light or dark.pnpm startspeaks MCP over stdio and enriches in-process. Point an MCP client at it (below).
Not using Docker? Any Postgres works if the
vectorextension is available (the first migration runsCREATE EXTENSION vector). SetDATABASE_URLto your instance and skippnpm db:up.
Connect an agent (MCP)
silo speaks MCP over three transports. Pick the one that matches where your agent runs.
1 · Local subprocess (stdio) — Claude Desktop / Claude Code on the same machine. No network, no auth: the process boundary is the trust boundary. Add to your MCP config:
{
"mcpServers": {
"silo": {
"command": "pnpm",
"args": ["--filter", "@silo/app", "start"],
"env": { "DATABASE_URL": "postgres://silo:silo@localhost:5432/silo" }
}
}
}
2 · Remote, with a token (HTTP) — a self-hosted silo an agent reaches over the network. Run
the MCP endpoint (SILO_MCP_HTTP_PORT + SILO_API_TOKEN; see Deploy) on whatever host
you choose, then point the agent at its /mcp URL with a bearer token — mint one in
Settings → API / MCP, where the Copy config button generates exactly this:
{
"mcpServers": {
"silo": {
"url": "https://<your-mcp-host>/mcp",
"headers": { "Authorization": "Bearer <YOUR_SILO_API_TOKEN>" }
}
}
}
Or, for Claude Code, one line:
claude mcp add --transport http silo https://<your-mcp-host>/mcp \
--header "Authorization: Bearer <YOUR_SILO_API_TOKEN>"
3 · URL-only connector (OAuth) — Claude and ChatGPT hosted connectors. No token to copy: paste the URL into "Add custom connector" and sign in. silo implements OAuth 2.1 + PKCE, Dynamic Client Registration, and discovery, so the whole flow is URL-only.
https://<your-mcp-host>/mcp
<your-mcp-host>is any host you point at the MCP endpoint — pick the name you like. The one rule: make it a single-level subdomain (e.g.mcp-links.example.com), not a nested one likemcp.links.example.com— many wildcard TLS certs don't cover a second level, and the OAuth discovery flow then fails at the proxy. Details:docs/methods/mcp-oauth.md.
Deploy
silo ships as one Docker image run as two roles — api (web UI + REST + worker) and mcp
(the HTTP MCP endpoint) — over a pgvector Postgres. Run the whole stack locally:
docker compose -f docker-compose.prod.yml up --build
The env vars that matter for a real deployment:
| Var | Role | What |
|---|---|---|
DATABASE_URL |
both | postgres://silo:<pw>@postgres:5432/silo (service name, not localhost) |
SILO_API_TOKEN |
both | bearer the HTTP MCP requires — openssl rand -hex 32 |
SILO_APP_PASSWORD |
api | web-UI login password (≥16 chars) — set it, or the UI is open |
SILO_SESSION_SECRET |
api | cookie-signing secret (falls back to SILO_APP_PASSWORD) |
SILO_PUBLIC_MCP_URL |
api | the exact MCP URL the "Copy config" button hands out |
SILO_MCP_ALLOWED_HOSTS |
mcp | your mcp hostname(s), comma-separated — required behind a proxy |
Behind a reverse proxy, SILO_MCP_ALLOWED_HOSTS is the one that bites: the MCP SDK's
DNS-rebinding guard rejects any Host it wasn't told to trust. Full walkthrough (Dokploy +
Traefik, TLS, the MCP-URL resolution order): docs/deploy.md.
Embed the web UI
Serve Silo over HTTPS to sign in inside another site's iframe. Embedded login uses an
HTTP-only partitioned cookie (SameSite=None; Secure; Partitioned). Modern browsers keep
that session separate for each top-level site. Sign in separately in the embed and in a
normal Silo tab. Signing out clears the sessions available in the current browser context;
it cannot clear a session stored under another top-level site. Normal tabs keep the existing
SameSite=Lax cookie. Browsers that cannot retain the embedded session show an explanation
and an Open Silo directly link.
Login, logout, and cookie-authenticated API writes require X-Silo-CSRF: 1; the web UI adds
it automatically. Bearer-token clients keep their existing request format. A separate web
frontend must be listed in SILO_ALLOWED_ORIGINS to pass the CORS preflight. The iframe's
parent does not need that access when Silo's UI and API share an origin. Deploy the API and
web bundle together, then reload existing tabs so they send the new header.
Clients
Reach silo from outside the app — each released independently
(docs/releasing.md). Point any client at your silo's base URL + an API token
(mint one in Settings → API / MCP).
- CLI — capture / search / list / open from the terminal:
brew install amitray007/tap/silo(or a tarball from the latestcli-v*release). - Chrome extension —
silo-capture-*.zipfrom the latestchrome-v*release, loaded unpacked. - Raycast extension — from the Raycast Store (search "silo").
Architecture
A TypeScript monorepo. Every operation goes through one core; adapters only translate to core calls, so the web UI and the agent can never drift.
packages/
core/ the brain — all operations + data access
db/ Postgres schema, migrations, queries (Drizzle)
worker/ background enrichment + scheduled jobs (purge / sweep / DLQ) ─▶ core
queue/ pg-boss setup shared by the worker and API ─▶ core
mcp/server/ MCP adapter — 18 tools ─▶ core
api/ HTTP adapter (Hono) — REST + OAuth server ─▶ core
web/ React SPA (Vite, "Oat" design) — talks to the API over HTTP
app/ composition root — runs the MCP server + worker as `silo`
The core/adapter boundary is mechanically enforced
(docs/rules/architecture.md).
Development
pnpm turbo run check-types test
pnpm quality # Biome + import boundaries + jscpd + knip
Pre-push runs typecheck and quality. CI also runs tests and builds; main must pass the full
gate. Tests hit a real Postgres via disposable databases. Conventions live in
docs/rules/.
Contributing & license
Contributions welcome — see CONTRIBUTING.md. Report vulnerabilities via
SECURITY.md. Licensed MIT © 2026 Amit Ray.
silo MCP questions
What kind of content can I capture?
You can feed in various web materials including URLs, Twitter/X posts, Hacker News posts, and videos.
How can I connect an AI agent to silo?
You can connect via a local subprocess using stdio, a remote connection using an HTTP bearer token, or via OAuth 2.1 for hosted connectors like Claude and ChatGPT.