pg.ddx.io How-to

DDX for PostgreSQL — How To Use Each Endpoint

Complete setup and usage guides for accessing PostgreSQL mailing lists and repositories.

For LLM clients: see /llms.txt for a structured index of all programmatic interfaces, suitable for autonomous agents that need to bootstrap context about pg.ddx.io quickly.

OVERVIEW

DDX for PostgreSQL offers multiple protocols to access the same data. Choose the one that fits your workflow:

What do you want to do?

Each answer lists the ways to do it, best first. All of them are free and need no account.

Keep your own copy of a mailing list

  1. Clone it with git. One transfer gets the whole list; later, git fetch brings only what is new.
    git clone https://pg.ddx.io/m/pgsql-hackers.git
    git -C pgsql-hackers fetch            # later
    Each commit is one message (public-inbox v2 format). Over SSH: git clone ssh://git@git.pg.ddx.io:22/pgsql-hackers.git Git clone setup →
  2. Mirror it into a mailbox with imapsync, if you want the mail in your own IMAP server rather than as git. Point it at imap.pg.ddx.io:993 with any username and password. Each list is split into numbered folders (pgsql-hackers.0 … .86), so select a numbered folder, not the bare list name. IMAP details →
  3. Download a range as mbox for a one-off: https://pg.ddx.io/m/pgsql-hackers/<from>-<to>.mbox.gz. The numbers come from /m/pgsql-hackers/info.json. mbox ranges →

Please do not build a copy by fetching messages one at a time over HTTP. It is far slower for you, and at scale it is what takes this one-server site down. See agents.txt.

Be told when new mail arrives on a list

  1. Subscribe to the list's feed in any feed reader: https://pg.ddx.io/m/pgsql-hackers/new.atom (or rss.xml). For new threads only: topics_new.atom; for threads with fresh replies: topics_active.atom. Feeds →
  2. Leave a mail client connected to imap.pg.ddx.io:993 on the newest numbered folder; the server pushes new mail with IMAP IDLE. IMAP IDLE →
  3. From code or an agent, poll with a cursor so you only ever see what is new: the get_new_messages MCP tool takes the last article number you saw and returns what came after it. get_new_messages →

Read a list without subscribing to it

  1. In your browser: browse the archive, threaded, with every message linked to the commits it led to.
  2. In your mail client, as a read-only account:
    IMAP server imap.pg.ddx.io, port 993, SSL/TLS, any username and password. Every list appears as folders. Nothing you do there can send mail or change anything. IMAP setup →
  3. In a newsreader: nntp.pg.ddx.io, port 563 with TLS, or 119 plain. Each list is a newsgroup (pgsql-hackers); read-only. NNTP setup →

Be told when new commits land in a repository

  1. Subscribe to the commit feed: https://pg.ddx.io/gitweb/?p=postgresql.git;a=atom. Each entry is one commit with its full message, including the Discussion: link back to the thread. Swap the project name for pgbouncer, pgjdbc, and the rest listed on /gitweb/. Commit feed →
  2. Follow the committers list if you would rather have it by mail: https://pg.ddx.io/m/pgsql-committers/new.atom, or the same list over IMAP. Read pgsql-committers →

Search commits the way you used to on git.postgresql.org

Use the same gitweb URLs with the host changed; the st= modes and a commit search box are in 4b. Or use the /api/v2/repos/postgres/commits?q= JSON API, or the git_search MCP tool.

The pg.ddx.io redirector sends postgr.es/m/… and postgresql.org/message-id/… links to the threaded view here, and gitweb links to the gitweb here. Available as a userscript for any browser and as a Chrome extension.

1. IMAP — Email Client Access

Purpose: Read mailing lists in your email client

IMAP treats each PostgreSQL mailing list as an IMAP folder. Once connected, you can browse, search, and read messages directly in Thunderbird, Apple Mail, Outlook, or any IMAP-compatible email client.

Setup

1. Get the server address:
imap.pg.ddx.io:993 (SSL/TLS) or imap.pg.ddx.io:143 (STARTTLS)
2. Open your email client and add a new account:
  • Thunderbird: File → New → Existing Mail Account → Enter any username/password → Configure manually
  • Apple Mail: Mail → Preferences → Accounts → + → Other Mail Account
  • Outlook: File → Account Settings → Account Settings → New → More Options
3. Configure account settings:
Server: imap.pg.ddx.io Port: 993 (SSL) or 143 (STARTTLS) Username: (any name, e.g., "postgres") Password: (any password, e.g., "readonly") Security: SSL/TLS or STARTTLS
4. Subscribe to mailing lists: Once connected, you'll see all 54 PostgreSQL mailing lists as folders:
pgsql-hackers pgsql-general pgsql-bugs pgsql-admin pgsql-performance ... (47 more)
Click "Subscribe" to add them to your folder list. Start with pgsql-general (most active, general discussion).

Usage

Example 1: Browse recent discussions

1. Click "pgsql-hackers" folder

2. Your email client shows the newest messages first

3. Click a message to read the full thread

Example 2: Search across a mailing list

1. In Thunderbird: right-click a folder → Search Messages

2. Search for: "VACUUM performance" across pgsql-performance

3. Results show all matching messages with context

Example 3: Get notifications

1. Set your client to check for new mail every 1 hour (Settings)

2. Enable notifications when new messages arrive

3. You'll get alerts for new pgsql-hackers discussions

Tips

  • No authentication needed: Use any username/password. We don't verify — all lists are public read-only.
  • Threading: IMAP preserves message threading, so replies are grouped under the original message.
  • Large mailboxes: Start with 2-3 lists. Adding all 85 lists may slow your client. You can add more later.
  • Offline access: Most email clients cache messages locally, so you can read offline and reconnect to sync.

2. POP3 — Download and Keep Locally

Purpose: Download mailing list messages to your computer permanently

POP3 downloads messages and removes them from the server. Use this if you want to keep a local archive of PostgreSQL discussions.

Setup

1. Server address:
pop.pg.ddx.io:995 (SSL) or pop.pg.ddx.io:110 (STARTTLS)
2. Email client configuration:
Server: pop.pg.ddx.io Port: 995 (SSL) or 110 (STARTTLS) Username: <UUID>@<newsgroup>[.<slice>][?initial_limit=N&limit=N] Password: anonymous Leave email on server: YES (to keep archival copy)

Username format is required and strict. The server replies -ERR no UUID@ in mailbox name if the <UUID>@ prefix is missing.

  • UUID: any 32-hex-digit identifier, dashes optional. It is an opaque per-client tracking ID, not a credential — pick one once and reuse it. Example: deadbeefdeadbeefdeadbeefdeadbeef or dead-beef-dead-beef-dead-beef-dead-beef.
  • newsgroup: the inbox to read, e.g. pgsql.hackers, pgsql.general, pgsql.bugs.
  • .slice (optional): integer slice number; omit for the latest slice.
  • ?initial_limit=N&limit=N (optional): cap the number of messages returned.
  • Password: must be the literal string anonymous.

Example username: deadbeefdeadbeefdeadbeefdeadbeef@pgsql.hackers

Usage

Set your client to check every 24 hours. All new messages download and stay on your computer. Good for backup and offline research.

3. NNTP — Newsreader Access

Purpose: Access mailing lists via a classic NNTP newsreader

If you use a newsreader (Thunderbird, Usenet clients), connect via NNTP. Each mailing list appears as a newsgroup.

Setup

1. Server address:
nntp.pg.ddx.io:563 (TLS) ← recommended nntp.pg.ddx.io:119 (plain text)

In Thunderbird, tick Use secure connection (SSL) and set the port to 563. No username or password is needed.

2. Add newsserver to your NNTP client:
  • Thunderbird: Edit → Preferences → Network & Storage → Newsgroup Servers → Add
  • Other newsreaders: Add server with the address above
3. Subscribe to newsgroups:
pgsql-hackers pgsql-general pgsql-bugs (etc.)

Note: Newsgroup names use hyphens, not dots.

Usage

Read and search the lists as you would any newsgroup. The server is read-only: it answers POST with 440 posting not allowed. To take part in a discussion, reply to the list by email.

4. Git — Clone a Mailing List as Repository

Purpose: Access mailing list history as a git repository for scripting/analysis

Clone any PostgreSQL mailing list as a git repository. Each message is a commit. Use this for data analysis, historical research, or building tools.

What these repositories actually are. The git URLs under /m/<inbox>.git are public-inbox v2 archives of mailing-list traffic. They are not mirrors of the upstream PostgreSQL source tree. Each commit is one email; the working tree contains the message's metadata and body. To clone the actual PostgreSQL source code or any other upstream project repository, go to its canonical home (for PostgreSQL: https://git.postgresql.org/git/postgresql.git). pg.ddx.io does not re-publish project source repos.

Setup

1. Clone via HTTPS:
git clone https://pg.ddx.io/m/pgsql-hackers.git
2. Or via SSH (if you have SSH access):
git clone ssh://git@git.pg.ddx.io:22/pgsql-hackers.git

Usage

Example 1: Find all messages by a specific author
git log --author="Greg Burd" --oneline | head -20
Example 2: Find commits about query optimization
git log --all --grep="query.*optim" --oneline
Example 3: Analyze discussion trends over time
git log --format="%ai" | cut -d' ' -f1 | sort | uniq -c | sort -rn

(Shows how many messages per day)

Tips

  • Large repositories: pgsql-hackers is ~190k commits. Clone may take 5-10 minutes.
  • Shallow clone (faster): git clone --depth 100 https://pg.ddx.io/m/pgsql-hackers.git
  • Script automation: Perfect for CI/CD pipelines that analyze historical discussions.

4a. Feeds & notifications — be told when something new arrives

Purpose: Follow a list or a repository without polling pages

New mail on a list

https://pg.ddx.io/m/pgsql-hackers/new.atom newest messages (Atom) https://pg.ddx.io/m/pgsql-hackers/rss.xml the same, as RSS https://pg.ddx.io/m/pgsql-hackers/topics_new.atom new threads only https://pg.ddx.io/m/pgsql-hackers/topics_active.atom threads with fresh replies

Replace pgsql-hackers with any list on the archive. The message feeds hold the 25 newest messages; the two topic feeds hold 50 threads.

New commits in a repository

https://pg.ddx.io/gitweb/?p=postgresql.git;a=atom

The 50 newest commits, newest first. Each entry is the full commit message, so the Discussion:, Reviewed-by: and Backpatch-through: trailers are there, and the link opens the commit. a=rss returns the same feed. Swap postgresql for any project on /gitweb/ — pgbouncer, pgjdbc, pgpool2, psqlodbc and the rest.

Push, in a mail client (IMAP IDLE)

Connect to imap.pg.ddx.io:993 and open the highest-numbered folder of the list (for pgsql-hackers, pgsql-hackers.86). Each list is split into numbered folders, and new mail lands in the last one. The server supports IDLE, so a client left open is told about new mail as it arrives.

From code or an agent

Poll with a cursor so you only ever receive what is new. The get_new_messages MCP tool takes the last article_num you saw and returns what came after it, with has_more when there is another page:

{"name": "get_new_messages", "arguments": {"after": 4324863}}

A range of messages as a file

https://pg.ddx.io/m/pgsql-hackers/<from>-<to>.mbox.gz

The numbers are article numbers, which are global across all lists rather than counted from 1 within each one — so 1-100 usually returns nothing. Read a list's current range from /m/pgsql-hackers/info.json. For a whole list, clone it instead.

4b. Git commit search (REST) — the gitweb replacement for agents

Purpose: Search and fetch commits from the actual project git repositories (postgres core + ecosystem) as JSON

This is a fast, agent-friendly alternative to git.postgresql.org/gitweb, which still serves browsing but answers a=search with HTTP 429 (checked 2026-10-22: summary pages 200, every search 429). Unlike the /m/<inbox>.git mailing-list repos above, these endpoints index the real source repositories — the full postgres history since 1996 (65k+ commits) plus ecosystem repos (pgbouncer, pgpool2, pgjdbc, and more). Commit-message search is backed by a Postgres full-text (pg_fts) index, so it stays fast under heavy automated load.

Your gitweb URLs keep working

The full postgres git history since 1996, searchable by commit message, author and file path. Your existing gitweb search URLs keep working: change the host and nothing else.

https://pg.ddx.io/gitweb/?p=postgresql.git;a=search;s=visibility+map;st=commit

st=commit searches commit messages, st=author and st=committer search names, and st=grep searches the source tree for a string and links each file and line.

As JSON: GET /api/v2/repos/postgres/commits?q=… · from an agent: the git_search MCP tool · or explore everything in the GraphQL explorer.

Setup

None. Any HTTP client. All responses are JSON.

Endpoints

EndpointReturns
GET /api/v2/reposList of indexed repositories.
GET /api/v2/repos/{name}/commits?q=…Commit log / search. Params below.
GET /api/v2/repos/{name}/commits/{sha}One commit: full message, author, committer, parent. sha is a full or ≥7-char git SHA.
GET /api/v2/repos/{name}/branchesBranch list.

/commits query parameters

ParamMeaning
qFull-text search of the commit message (pg_fts, index-backed). Words are AND-ed; the operators of the search page work here, so from:, after: and before: narrow by author and date. Quotes, | and -word are not applied to commits; use -intext:word to exclude a word.
authorFilter by author name or email fragment (the same as from: in q).
limit, offsetPage size (default 50, max 200) and offset.
trailerA commit trailer, Key=Value or Key (also trailer:Key=Value in q).
Example 1: Search postgres commit messages
curl -s 'https://pg.ddx.io/api/v2/repos/postgres/commits?q=visibility+map+freeze&limit=5' | jq '.commits[] | {commit, subject, author}'

Each result has commit (the git SHA), subject, author, email, and date.

Example 2: Fetch one commit in full
curl -s 'https://pg.ddx.io/api/v2/repos/postgres/commits/deadbeef' | jq '{commit, subject, message, committer}'

A full or ≥7-char SHA prefix resolves to the commit with its complete message, committer, and parent id.

Example 3: Commits by an author in a date range
curl -s 'https://pg.ddx.io/api/v2/repos/postgres/commits?q=from:%22Tom+Lane%22+after:2020+before:2021&limit=200' | jq '.count'

Commits by a file path or on one branch are in the any-version code history: GET /api/v2/code/history/commits?paths=src/backend/access/heap/vacuumlazy.c&range=REL_14_STABLE.

Code browser. We index far more than commit messages: a symbol graph (functions, structs, macros, types across C, Rust, SQL, Java, C++, Python, Go), a call graph, and the full file content of every repo we mirror. A GitHub/Forgejo-class browser is built on top of it: /c/postgres/ is the tree at the default branch's head, and /c/<repo>/<commit, branch or tag>/<path> a tree or a syntax-highlighted file at that commit (#L120-L140 selects lines), with the commit's message and links, older/newer commit links (keys [ and ]), ?blame=1, ?changes=1 (that commit's diff), identifiers linking their definition and a #define's expansion on hover. /search's Code at a commit (src=code&rev=, or GET /api/v2/code/at) finds text and symbols at one commit. The older forms /c/<repo>/blob/<commit>/<path> and /c/<repo>/tree/<commit>/<path> still work, a git-blame where every line's commit metadata is a link (/c/<repo>/blame/<commit>/<path> — to the commit, the author's people page, the CVE it fixed, the discussion thread it came from), a per-file symbol outline, code & symbol search with GitHub-style filters (lang:, path:, symbol:, kind:, repo:; also GET /api/v2/code/search and /api/v2/code/symbol), and in-browser diffs between two points in time (/c/<repo>/compare/<base>...<head>). The gitweb views remain for raw blobs and the classic surface.

5. HTTP/REST — Programmatic Access

Purpose: Search and fetch mailing-list content with plain HTTP, no client library needed

Every indexed inbox has a search endpoint at https://pg.ddx.io/m/<inbox>/?q=<term>. Add &format=json to get JSON instead of the HTML view. Each inbox is also exposed as a public-inbox v2 git repository at https://pg.ddx.io/m/<inbox>.git.

Note: indexes are populated from upstream archives over time. If you query an inbox that's still importing you'll see “No messages yet.” or “Search is not available for this inbox.” That's import lag, not breakage. Inboxes confirmed populated today include pgsql-announce, pgsql-committers, pgsql-performance.

Setup

None. curl, wget, fetch, or any HTTP client.

Usage

The endpoint https://pg.ddx.io/m/<inbox>/?...&format=json accepts these query parameters. Filters are operators inside q; they combine (all must hold).

ParamMeaning
qThe query: words, and the operators of the search page (intitle:, from:, after:, before:, /regex/, …). Required.
format=jsonReturn JSON instead of HTML.
limit, oPage size (default 50, max 1000) and offset.
Example 1: Full-text search, JSON output
curl -s 'https://pg.ddx.io/m/pgsql-announce/?q=pgbouncer&format=json' | jq '.total, .results[0]'

Returns the total hit count and the first match for “pgbouncer” in pgsql-announce. Each result has subject, from, date, message_id, thread_url, message_url, and a BM25 relevance score.

Example 2: Multi-term search with paging
curl -s 'https://pg.ddx.io/m/pgsql-committers/?q=patch&format=json&limit=10&o=0' | jq '.results[].subject'

Search a different inbox; limit and o (offset) page through results. Drop &format=json to render the same query as a browseable HTML page.

Example 3: Filter by subject only
curl -s 'https://pg.ddx.io/m/pgsql-announce/?q=intitle:release&format=json&limit=2' | jq '.total'

Restrict the match to the Subject header (intitle:, also subject:). Useful when the body is noisy or you only care about announcement-style headlines.

Example 4: Filter by sender
curl -s 'https://pg.ddx.io/m/pgsql-announce/?q=from:announce-noreply&format=json&limit=2' | jq '.results[0].from'

Match a fragment of the From header (display name or address).

Example 5: One message by its Message-ID
curl -s 'https://pg.ddx.io/m/pgsql-announce/177913516055.803.10890499456720421868@wrigleys.postgresql.org/info.json' | jq '.subject'

The message as JSON: headers, the decoded body and its attachments. If you do not know the list, https://pg.ddx.io/id/<message-id> redirects to it.

Example 6: Date range
curl -s 'https://pg.ddx.io/m/pgsql-announce/?q=release+after:2024-01-01+before:2024-04-01&format=json&limit=5' | jq '.total, .results[].subject'

Q1 2024 only. after: includes the day, before: does not. Dates combine with any other operator.

Example 7: Regex search
curl -s 'https://pg.ddx.io/m/pgsql-announce/?q=intitle:%2Frelea%5Bsz%5De%2F&format=json&limit=2' | jq '.total'

A PostgreSQL regular expression between slashes, here on the subject (intitle:/relea[sz]e/): it matches both “release” and “releaze”. URL-encode /, [, ], + and the like.

Example 8: Subscribe to new messages via Atom
curl -s 'https://pg.ddx.io/m/pgsql-announce/new.atom'

Standard Atom feed of recent messages. Poll no more often than once every 5 minutes — the feed only changes when new mail arrives, and aggressive polling wastes bandwidth on both sides. Most feed readers default to 30–60 minutes, which is appropriate.

Example 9: Fetch one message as raw RFC822
curl -s 'https://pg.ddx.io/m/pgsql-announce/177913516055.803.10890499456720421868@wrigleys.postgresql.org/raw'

Returns the original message bytes, including all headers and the unmodified body. URL pattern is /m/<inbox>/<message-id>/raw. Pipe into your own MIME parser or save to disk for archival.

Example 10: Bulk export a range as gzipped mbox
curl -s 'https://pg.ddx.io/m/pgsql-committers/1-100.mbox.gz' > pgsql-committers-1-100.mbox.gz zcat pgsql-committers-1-100.mbox.gz | head -20

URL pattern is /m/<inbox>/<begin>-<end>.mbox.gz, where begin and end are public-inbox v2 article numbers. Range is capped at 10000 messages per request. Use this to seed a local mbox archive without cloning the full git repo.

Example 11: Clone an inbox as a git repo
git clone https://pg.ddx.io/m/pgsql-announce.git

Public-inbox v2 layout. Run your own indexer or mirror locally for offline analysis. (Reminder: this is the mailing-list archive, not upstream PostgreSQL source.)

Tips

  • JSON or HTML: the same URL serves both — toggle with &format=json.
  • Paging: add ?limit=N&offset=M. Default limit is 50, max 1000 (server-enforced).
  • Browse first: visit https://pg.ddx.io/ in a browser to see the full inbox list and pick one.
  • Structured tools: for symbol search, call graphs (get_callers and get_callees), commitfest queries, etc., use the MCP server (Section 1) — those are JSON-RPC tool calls, not REST endpoints.

6. GraphQL — Structured Queries

Try it live: the GraphQL explorer runs queries against the real endpoint and has a Docs pane generated from the schema itself.

Purpose: Ask for exactly the fields you want, in one round trip

The GraphQL endpoint exposes the same data as the REST API but lets the caller specify which fields they want. Useful when you'd otherwise be making N requests in a loop and stitching JSON together.

Endpoint: POST https://pg.ddx.io/api/graphql (Content-Type: application/json). GET with a ?query=… parameter also works for read-only queries. There is no /<inbox>/graphql URL — every Query field takes an explicit inbox: String! argument instead.

Interactive explorer: open https://pg.ddx.io/api/graphql in a browser and you get the GraphiQL UI with schema introspection, autocomplete, and query history. Programmatic clients (curl, fetch with Accept: application/json) keep getting the JSON API as before.

Schema

Top-level Query fields:

  • inbox(inbox: String!) — metadata: name, description, addresses, message count, last-modified.
  • messages(inbox: String!, limit: Int = 25) — recent messages.
  • message(inbox: String!, mid: String!) — one message by Message-ID, including body and attachments.
  • thread(inbox: String!, mid: String!) — full thread rooted at a Message-ID.
  • search(inbox: String!, query: String!, limit: Int = 50, offset: Int = 0) — BM25 search; results carry a relevance score.

Usage

Example 1: Inbox metadata + recent search results in one request
curl -s -X POST -H 'Content-Type: application/json' \ -d '{"query":"{ inbox(inbox:\"pgsql-announce\") { name messageCount lastModified } search(inbox:\"pgsql-announce\", query:\"pgbouncer\", limit:3) { total results { subject date relevance } } }"}' \ https://pg.ddx.io/api/graphql

Returns both the inbox header and the first three search hits in one round trip. Compare with the REST API, which would require two calls.

Example 2: Pull a full thread by its root Message-ID
curl -s -X POST -H 'Content-Type: application/json' \ -d '{"query":"{ thread(inbox:\"pgsql-hackers\", mid:\"CABwTF4Wfs+u_O...@mail.gmail.com\") { rootMessageId messageCount messages { subject from date } } }"}' \ https://pg.ddx.io/api/graphql

Replace the mid value with a real Message-ID from the inbox you care about (you can copy one from a REST search response or the HTML view). Add body to the messages selection set if you also want the message text.

Tips

  • Errors are inline. A query that hits a missing inbox or a bad Message-ID still returns HTTP 200 with the failure inside an errors array. Check both data and errors in your client.
  • The inbox argument is required on every field. The endpoint is not scoped to any inbox; the schema deliberately surfaces the inbox name in each query so a single GraphQL request can span multiple inboxes by aliasing.
  • 1 MiB request body cap. Plenty for normal queries; chunk large mutations (none are exposed today — this is a read-only API).

7. MCP — For AI Agents

Purpose: let an AI agent search and read the whole archive

The MCP server gives an agent the mailing lists back to the 1990s, the full postgres history, commitfest and buildfarm as tools it can call rather than pages it has to scrape. It does retrieval; your own model writes the answer, citing what the tools returned.

Endpoint

https://pg.ddx.io/mcp

MCP Streamable HTTP (JSON-RPC 2.0). No key, no account. A plain GET of that URL returns a short JSON description of the server; clients POST to it. /mcp-tools is not an endpoint — it is the human-readable reference for the tools.

Setup

Claude Code
claude mcp add --transport http pg-ddx https://pg.ddx.io/mcp
Codex
codex mcp add pg-ddx --url https://pg.ddx.io/mcp

Or in ~/.codex/config.toml:

[mcp_servers.pg-ddx]
url = "https://pg.ddx.io/mcp"
GitHub Copilot CLI
copilot mcp add --transport http pg-ddx https://pg.ddx.io/mcp

This writes ~/.copilot/mcp-config.json:

{"mcpServers": {"pg-ddx": {"type": "http",
  "url": "https://pg.ddx.io/mcp", "tools": ["*"]}}}
VS Code

In .vscode/mcp.json (VS Code uses servers, not mcpServers):

{"servers": {"pg-ddx": {"type": "http", "url": "https://pg.ddx.io/mcp"}}}
Cursor

In ~/.cursor/mcp.json:

{"mcpServers": {"pg-ddx": {"url": "https://pg.ddx.io/mcp"}}}
Zed

In settings.json:

{"context_servers": {"pg-ddx": {"url": "https://pg.ddx.io/mcp"}}}
OpenCode

In opencode.json:

{"$schema": "https://opencode.ai/config.json",
 "mcp": {"pg-ddx": {"type": "remote", "url": "https://pg.ddx.io/mcp", "enabled": true}}}
Any other client

MCP Streamable HTTP at https://pg.ddx.io/mcp; clients that only speak the legacy SSE transport use https://pg.ddx.io/mcp/sse. No key, no account.

/mcp lists the core tools; every tool (129) is at /mcp/full.

A retrieval loop that works

  1. retrieve_context {"query": "...", "token_budget": 4000} — start here: cited passages that fit the budget, one per thread, or found: false when the archive does not discuss the question.
  2. hybrid_search {"query": "..."} — ranked hits, each with an excerpt of the author's own words, so you can judge a hit without opening it.
  3. get_message {"message_id": "...", "body_only": true} — one message in full.
  4. get_thread {"message_id": "...", "include_bodies": false} — an outline of the whole thread; then fetch the messages that matter. Threads are paged (20 messages per call).
  5. git_search and commit_history — from a discussion to the commit it produced, and back.

Omit inbox on a mail search and it searches every list; on get_message/get_thread it defaults to pgsql-hackers; omit repository and it is postgres. All tools and their arguments →

Ready-made skills

Pre-built, CC0 (public-domain) agent skills for Claude, Kiro, Pi, and any MCP-aware agent — written once for every agent (no per-agent branches). They are grouped by how you work with Postgres (query user, DBA, design overseer, replication, triage, core/extension developer), plus tooling and generic agent skills, and include a 41-rule PostgreSQL best-practices library. Browse the full catalogue at gburd.github.io/postgres-agent-skills, or clone the repository into your agent's skills directory:

git clone https://github.com/gburd/postgres-agent-skills.git ~/.claude/skills/postgres

Then point the agent at AGENTS.md at the repo root. It's a shared community resource — issues and PRs welcome at github.com/gburd/postgres-agent-skills.

Tips

  • Authentication: none. Public and read-only.
  • Rate limits: light, per client. A throttled request gets HTTP 429; back off and retry.
  • Bulk copies: please clone the list rather than fetching every message through tools. See agents.txt.

WHICH SHOULD I USE?

Use Case Best Endpoint Why
Browse discussions like email IMAP Familiar email client, threading, search built-in
Download archive to computer POP3 Keep local copy, work offline
Old-school newsreader fan NNTP Classic protocol, powerful newsreaders available
Build tools / analyze history Git Version control, scripting, full history
Quick searches / dashboards HTTP/REST Simple API, JSON responses, easy integration
AI agent integration MCP Purpose-built for AI, structured queries, 100+ tools

FINDING THE BERKELEY POSTGRES HISTORICAL ARCHIVE

pg.ddx.io mirrors the University of California, Berkeley POSTGRES project (1986–1995) — the academic predecessor of PostgreSQL — at /legacy/. The upstream archive at dsf.berkeley.edu/postgres.html has been effectively static since 1999; this mirror exists so the bytes survive if the upstream ever disappears.

Mailing list (1991–1997)

The original UCB POSTGRES hackers list, including design-era discussions from Stonebraker and the original implementors:

Project documentation, papers, FAQ

The archive contains the CONCERT Trouble Ticket System (a contrib sample application), not bug tickets — UCB never used a bug tracker for the project. Patch discussions and design exchanges are in the mailing list.

Source code

Before POSTGRES: University INGRES

INGRES (UC Berkeley, 1973–1988) preceded POSTGRES. Its archive at s2k-ftp.cs.berkeley.edu/ingres/ is mirrored at /legacy/ingres/:

TROUBLESHOOTING

IMAP won't connect

No folders appear after connecting

HTTP search returns no results

Git clone too slow

OPENAPI 3.1 SPECIFICATION

Purpose: machine-readable contract for the entire HTTP surface

Every public HTTP endpoint described on this page is also documented in a single OpenAPI 3.1 document — search, single-message JSON, raw RFC 822, threads, Atom/RSS feeds, inbox metadata, the help/color/mirror text pages, the git smart-HTTP transport, /healthz, and the MCP JSON-RPC envelope.

The spec is served by the service itself at /openapi.yaml and rendered as an interactive Swagger UI page at /api.html. Both are kept in lock-step with the service's route table.

Usage

Browse the API in your browser
https://pg.ddx.io/api

Loads Swagger UI from a CDN and points it at the live spec. Each endpoint has a “Try it out” button that issues real requests against the production service.

Fetch the raw spec
curl -s https://pg.ddx.io/openapi.yaml | head -40

Useful for embedding in your own docs site, validating with spectral lint, or generating clients with openapi-generator.

Generate a typed client
openapi-generator-cli generate -i https://pg.ddx.io/openapi.yaml -g python -o ./pgesq-client

Replace python with any of the supported targets (typescript-fetch, go, rust, etc.). The generated client speaks JSON only — for the HTML, Atom, RSS, and git smart-HTTP routes you still need a regular HTTP client.

Tips

  • Same URL, two formats: the search endpoint defaults to HTML; add &format=json for the JSON envelope. The OpenAPI document only describes the JSON variant.
  • Pagination: follow Link headers (RFC 8288 rel="next" / rel="prev" / rel="first") instead of recomputing offsets. The body's has_more is also reliable.
  • MCP for agents: the POST /mcp/ entry in the spec describes the JSON-RPC envelope. AI agents should use a real MCP client library; the OpenAPI is there mostly for debugging.

QUESTIONS?

Something not working as described? Get in touch. We want these endpoints to work perfectly.