SGU MCP
Allows semantic search using OpenAI's embedding API for higher quality query embeddings.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@SGU MCPSearch SGU transcripts for cold fusion."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
SGU MCP
An MCP server for The Skeptics' Guide to the Universe podcast — search transcripts, look up episodes, pull Science or Fiction, and search news items, all from inside Claude.
It ships in three forms:
A local MCP server (
npx sgu-mcp) for Claude Desktop / Claude Code / any MCP client.A remote MCP connector (Streamable HTTP) you can host so people connect their own Claude account and search the archive — no per-request cost to you.
A zero-backend web archive (
web/) — a static site where search runs entirely in the visitor's browser, with an optional "Ask Claude" panel (bring your own API key).
Requires Node ≥ 22.5 (uses the built-in node:sqlite — no native build step).
Quick start (local MCP server)
# Claude Code
claude mcp add sgu -- npx -y sgu-mcpOr add it to your MCP config manually (~/.claude/mcp.json or Claude Desktop's config):
{
"mcpServers": {
"sgu": {
"command": "npx",
"args": ["-y", "sgu-mcp"]
}
}
}Restart Claude, then try: "What was the Science or Fiction theme on SGU 1075?" or "Search SGU transcripts for cold fusion."
The live wiki/RSS tools work immediately. The fast local-archive tools need an index — download a prebuilt one in seconds:
npm run setup # downloads the prebuilt full-text index (data/sgu.db)…or build it yourself (see Building the archive).
Related MCP server: MCP Podcast Scraper
The two data layers
Local archive — every episode transcript scraped into
episodes/NNNN.md(YAML frontmatter + clean Markdown) and indexed into a SQLite FTS5 database (data/sgu.db) for instant, bm25-ranked, offline full-text search.Live wiki/RSS tools — for the newest episodes (whose transcripts aren't on the wiki yet) and as a fallback before the archive is built.
Data sources
No official SGU API exists (the website is a locked-down SPA). This server pulls from two reliable public sources:
Source | Used for |
sgutranscripts.org (MediaWiki API) | transcript search, episode segments, news items, Science or Fiction, full transcript text |
Podcast RSS feed (libsyn) | latest/recent episodes, release dates, audio URLs |
Note: Transcripts are volunteer-made and lag the feed by a few weeks. The newest episodes show up in
get_latest_episodes(RSS) before their transcript exists on the wiki.
Tools
Local archive (fast, offline, ranked — prefer these):
Tool | What it does |
| bm25-ranked FTS5 search over the whole archive (episode-level), highlighted snippets + metadata. Optional |
| Segment-level search — returns the exact moments with timestamp + speaker ("jump to the moment"). Filters: |
| Real occurrence count of a word/phrase across the archive, with breakdowns by year, by speaker, and top episodes. Answers "how many times did they say X?". |
| Natural-language / conceptual search. Blends vector similarity with BM25 (reciprocal-rank fusion). Needs the embedding index ( |
| Full Markdown doc (frontmatter + transcript) for an episode from the local archive. |
| Episode + segment counts, date range, and which embeddings are present. |
Live wiki / RSS (newest episodes + fallback):
Tool | What it does |
| Live full-text search of sgutranscripts.org. |
| One episode by number: title, date, rogues, guests, quote of the week, segment outline (timestamps), news items + links, Science or Fiction, audio URL. |
| The most recent episodes from the RSS feed (number, date, summary, audio). |
| The SoF theme + items + source links, and which item was the fiction (when machine-encoded; otherwise returns the segment transcript so the reveal can be read off). |
| Search the science news items the show has covered; returns topic, episode, link. |
| Cleaned transcript text — whole episode, or a single named section. |
Building the archive
If you'd rather build the index from scratch instead of npm run setup:
npm run fetch # scrape all ~1000 transcripts -> episodes/*.md (resumable; skips existing)
npm run index # build data/sgu.db (SQLite FTS5) from the .md corpusfetch is polite (limited concurrency, rate-limited, retries) and resumable — re-running only
fetches missing episodes. Use --force to re-scrape, or --only 1075,1074 for specific episodes.
Segment index & semantic search
npm run index builds two layers from the corpus: the episode FTS index and a
segment index (one row per speaker turn, ~178k rows) that powers search_segments
(timecoded, per-speaker) and count_mentions (true occurrence counts).
For conceptual / natural-language search, build the embedding index:
npm run embed # local model (default) — no API key, no cost
EMBED_PROVIDER=openai npm run embed # needs OPENAI_API_KEY (one-time, ~cents)
EMBED_PROVIDER=voyage npm run embed # needs VOYAGE_API_KEYEmbeddings are episode-level (one vector each), computed once. semantic_search then
blends them with keyword ranking. The provider for query embedding is set by
EMBED_PROVIDER (default local, via @xenova/transformers, an optional dependency).
A note on Science or Fiction answers
The fiction item is reliably structured only when the transcription bot encoded it
(answerKnown: true). Otherwise the reveal lives in the discussion prose, so the tool returns the
SoF segment transcript and answerKnown: false — Claude reads the answer from it.
Remote MCP connector (search with your own Claude account)
Host the server over Streamable HTTP and people can add it as a connector in Claude (Desktop / Code / Team / Enterprise), searching the archive with their own Claude subscription.
npm run build
SGU_MCP_TOKEN=$(openssl rand -hex 24) npm run start:http # serves POST /mcp on :8788Health check:
GET /healthzMCP endpoint:
POST /mcp(stateless Streamable HTTP — a fresh server per request)Auth: if
SGU_MCP_TOKENis set, clients must sendAuthorization: Bearer <token>. If it's not set, the server binds to loopback only, so you can't accidentally expose an unauthenticated endpoint.
Add it in an MCP client with a bearer header, e.g. Claude Code:
claude mcp add --transport http sgu https://your-host.example.com/mcp \
--header "Authorization: Bearer <token>"Deploy on Render: render.yaml defines the connector as a Node web service
(sgu-mcp-connector). It downloads the prebuilt index at build time (no scraping), serves the same
12 tools, and reads SGU_MCP_TOKEN from the dashboard.
Public Claude.ai connector? Anthropic's hosted Claude.ai expects a full OAuth 2.1 flow for custom remote connectors. The bearer-token mode here is perfect for self-hosting and for Desktop/Code/Team custom connectors; putting an OAuth proxy (or an MCP-aware gateway) in front is the next step for a public listing. The tool layer is unchanged either way.
The fan-facing web archive (web/)
A fully static, zero-backend search site. Search runs entirely in the visitor's browser — no server, no API key — so it costs nothing to run no matter how much traffic it gets.
How it works: the FTS5 database is served as a static file and queried in-browser via
sql.js-httpvfs(SQLite compiled to WASM). HTTP range requests mean the browser only downloads the few KB of DB pages each query touches — not the whole file.What fans can do:
Full-text search across every transcript, bm25-ranked, with highlighted snippets.
Counting questions — "how many times was homeopathy mentioned in 2024?" → a number, a per-year breakdown, and the episodes themselves.
Filter by year; jump straight to the transcript or the audio.
"Find by meaning" (semantic search) with two modes, so it works for everyone and never costs you per query:
Free — embeds the query in the visitor's browser via
@xenova/transformers(loads a ~25 MB model once). No key, no cost; a little slower.Best — the visitor pastes their own OpenAI key; their browser calls OpenAI for the query embedding (fast, highest quality). Requires that you published OpenAI doc vectors once (
EMBED_PROVIDER=openai npm run embed); otherwise the panel says so and Free mode still works. Doc vectors ship inside the static DB, so ranking happens entirely in the browser.
Optional "Ask Claude" — a BYOK panel where the visitor pastes their own Anthropic API key; their browser calls the API directly (never this site), and Claude answers from the top transcript excerpts, citing episode numbers. See SECURITY.md.
Build & run the web archive locally
npm run setup # download the prebuilt index (or fetch + index yourself)
npm run web # prepares web/sgu.db (single-file, vacuumed, range-ready)
npm run web:serve # http://localhost:8787 (range-aware static server)The web/vendor/ files (sql.js-httpvfs) are committed so the site is self-contained and works
offline — browsers block cross-origin Worker scripts, so they must be served same-origin.
Deploy the website to Render
render.yaml's sgu-archive static site downloads the prebuilt index and prepares the browser DB —
no scraping at deploy time, so deploys are fast and gentle on the volunteer wiki:
buildCommand: npm ci && npm run setup && npm run web
staticPublishPath: ./webHow the archive stays fresh
.github/workflows/publish-db.yml runs monthly (and on demand) in GitHub's cloud — works with
your Mac closed. It scrapes new transcripts, rebuilds the index, and publishes it to the db-latest
GitHub Release. Everything downstream (npm run setup, the connector, the website) just downloads
that artifact — one polite scrape feeds them all. If you set a RENDER_DEPLOY_HOOK_URL repo secret,
it also pings Render so the website redeploys with the new data.
Development
npm run dev— run the stdio server from source withtsx(no build step)npm run dev:http— run the HTTP connector from sourcenpm run smoke— live test against SGU sourcesSource:
src/—server.ts(the 12 tools),index.ts(stdio entry),http.ts(HTTP entry),wiki.ts(MediaWiki client),rss.ts(feed),parse.ts(wikitext parsers),db.ts(FTS5 + segments + vectors),segments.ts(speaker-turn parser),embeddings.ts(providers)
See CONTRIBUTING.md. Code is MIT (LICENSE); transcript/audio content belongs to their authors — this is an unofficial fan tool.
Available Tools
12 toolsarchive_statsSGU local archive statsA
Report how many episodes are in the local indexed archive and the date range covered. Use to check whether the archive is built and how complete it is.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, but the description implies a read-only operation by using 'report'. While it doesn't explicitly state non-destructiveness, the benign nature of a stats tool is conveyed. Slightly lacking full disclosure but acceptable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no wasted words. Front-loaded with the primary output (episodes count and date range) followed by usage guidance. Efficient and readable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simplicity (zero parameters, no output schema), the description adequately conveys purpose and usage. It could mention the return format, but not necessary for basic completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, and schema coverage is 100%. The description does not need to add parameter meaning. Baseline 4 for no parameters.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it reports the number of episodes and date range in the local indexed archive, using specific verb 'report' and resource 'local indexed archive'. It distinguishes from sibling tools like search and retrieval by focusing on archive status.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states 'Use to check whether the archive is built and how complete it is', providing clear context and purpose. No ambiguity about when to use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
count_mentionsCount SGU mentions of a termA
Count how many times a word or phrase is actually said across the whole archive — a real occurrence count, not just how many episodes match. Returns the total, segments/episodes matched, and breakdowns by year, by speaker, and the top episodes by frequency. Use for questions like 'how many times have they said homeopathy?' or 'who says "awesome" the most?'. Matches the stem and its inflections (e.g. homeopath → homeopathy, homeopathic). Covers transcribed episodes only (a few weeks behind release).
| Name | Required | Description | Default |
|---|---|---|---|
| term | Yes | The word or phrase to count (stem; inflections are included) | |
| top_episodes | No | How many top episodes to list (default 10) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, description discloses stem matching, coverage scope, and output components (total, segments/episodes, breakdowns). Missing details on rate limits or idempotency, but sufficient for safe invocation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences efficiently convey purpose, use cases, behavior, and limitations. Some repetition ('real occurrence count' vs 'not just how many episodes match') could be tightened, but overall well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite no output schema, description details return values (total, segments/episodes, breakdowns by year/speaker/top episodes). Covers input, behavior, and output fully for a simple tool with two params.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers both parameters (term, top_episodes) with descriptions. Description adds context: stem/inflection matching for term, default of 10 for top_episodes. Adds value beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool counts occurrences of a word or phrase across the archive, distinguishing it from sibling tools that return matching episodes or segments. It emphasizes 'real occurrence count' not just episode matches.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit example queries and clarifies the tool counts occurrences per speaker and year. Mentions coverage limitation (transcribed episodes). Could be improved by noting when not to use (e.g., for exact phrase matching without stemming).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_episodeGet an SGU episodeA
Get a structured overview of one episode by number: title, date, rogues present, guests, quote of the week, the segment outline (with timestamps), news items (with source links), Science or Fiction, audio URL, and links. Combines the RSS feed (recent metadata + audio) with the transcript wiki (segments + details). Use get_transcript for the full text.
| Name | Required | Description | Default |
|---|---|---|---|
| episode_number | Yes | Episode number, e.g. 1075 |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses internal data sources and behavior: 'Combines the RSS feed (recent metadata + audio) with the transcript wiki (segments + details).' This is fully transparent despite no annotations, and there is no contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no waste: first sentence defines purpose and contents, second sentence explains data sources and provides guidance on an alternative tool. Front-loaded and efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter tool with no output schema, the description is fully complete: it specifies input, output contents, internal behavior, and when to use a sibling. No gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter, episode_number, is already described in the schema (100% coverage). The description adds 'by number' but no additional meaning beyond schema. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description starts with a specific verb+resource 'Get a structured overview of one episode by number' and lists the included fields, clearly distinguishing the tool from its siblings, such as get_transcript.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use this tool vs. an alternative: 'Use get_transcript for the full text.' This provides clear guidance on which tool to choose based on desired output.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_episode_markdownGet archived episode markdownA
Return the full Markdown document (YAML frontmatter + clean transcript) for an episode from the local archive. Frontmatter includes date, rogues, guests, theme, the Science-or-Fiction answer, news items with links, audio URL, and source. Use after search_episodes to read the full text.
| Name | Required | Description | Default |
|---|---|---|---|
| episode_number | Yes | Episode number, e.g. 1075 |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, and the description does not disclose behavioral traits such as read-only nature, required permissions, or performance implications. Listing contents is not sufficient for transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences convey all necessary information with no waste. First sentence defines the output; second sentence lists contents and gives a usage hint.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter, no output schema), the description adequately describes the return format (Markdown with frontmatter and transcript). It could be more detailed about the transcript format but is sufficient for its role.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema has 100% coverage, with a clear description of the single parameter (episode_number). The description adds no additional parameter guidance beyond the schema, meeting the baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (return Markdown document) and the resource (episode from archive). It specifies the contents (YAML frontmatter + clean transcript) and distinguishes itself from siblings like get_episode and get_transcript.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly advises 'Use after search_episodes to read the full text,' providing clear when-to-use context. It does not list when not to use, but the sibling list implies alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_latest_episodesGet latest SGU episodesA
List the most recent episodes from the podcast RSS feed: number, title, date, summary, audio URL. Use to find the newest episode or recent ones. Note: transcripts lag a few weeks behind release.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | How many recent episodes (default 5) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavior. It reveals that the tool reads from an RSS feed (non-destructive), lists recent episodes, and notes that transcripts lag. No permissions or side effects are mentioned, but for a simple read operation, this is adequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences and a note, efficiently front-loading the key information (what the tool does and the returned fields) with no unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple list tool with one parameter and no output schema, the description covers the purpose, returned fields, and a practical caveat (transcript lag). It is sufficient for an agent to invoke correctly without additional context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter (limit) is fully documented in the schema with description, min, and max. The description adds no additional semantic value beyond what the schema provides, so the baseline score of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it lists recent episodes from the RSS feed and specifies the returned fields (number, title, date, summary, audio URL). This distinguishes it from siblings that retrieve specific episodes or search, making the tool's purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a clear use case ('Use to find the newest episode or recent ones') and includes a note about transcript lag. However, it does not explicitly mention when not to use this tool or suggest alternative tools like search_episodes for query-based searches.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_science_or_fictionGet Science or FictionA
Get the Science or Fiction segment for an episode: the theme, the items (with source links), and which item was the fiction WHEN it is machine-encoded (answerKnown=true). When answerKnown=false, the reveal isn't in structured data — the transcript of the segment is included so the answer can be read off the discussion.
| Name | Required | Description | Default |
|---|---|---|---|
| episode_number | Yes | Episode number, e.g. 1075 |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully discloses behavioral traits: it explains the conditional return of structured answer vs. transcript based on answerKnown, and mentions source links for items. This is transparent for a read-only tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences, front-loaded with the tool's purpose, and every sentence adds value. No redundant or vague wording.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter, no output schema), the description thoroughly explains what is returned and how it varies. It covers all necessary behavioral context for the agent to use it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, and the schema already describes episode_number as 'Episode number, e.g. 1075'. The description does not add significant parameter-specific semantics beyond reinforcing the purpose, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves the Science or Fiction segment for an episode, specifying the return content: theme, items with source links, and the fiction item (when available) or transcript. This is specific and distinguishes it from siblings like get_episode or get_transcript.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides implicit guidance on when to use this tool (for Science or Fiction segments) and explains conditional behavior based on answerKnown. However, it does not explicitly compare to sibling tools or state when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_transcriptGet SGU transcript textA
Get the cleaned transcript text of an episode. By default returns the full transcript (can be long). Pass a 'section' substring (e.g. 'Science or Fiction', a news item title, or 'Intro') to return only that section's text. Use get_episode first to see the segment outline.
| Name | Required | Description | Default |
|---|---|---|---|
| episode_number | Yes | Episode number, e.g. 1075 | |
| section | No | Optional: case-insensitive substring of a section heading to return just that section |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Describes the 'cleaned' nature and length warning. Explains section behavior (case-insensitive substring). No annotations, so burden is higher. Missing details on return format or potential errors.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences. First states purpose, second details optional parameter and prerequisite. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Covers main functionality and parameter use. Lacks output schema description (no mention of return format). For a simple tool without output schema, mostly complete but could include what the response looks like.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, baseline 3. Description adds meaningful context: full transcript can be long, section is case-insensitive substring. Adds value beyond schema but not extensive.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it retrieves cleaned transcript text for an episode. Specifies optional section filter. Distinguishes from siblings by noting to use get_episode first for segment outline.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides context on when to use the section parameter and recommends using get_episode first. However, does not explicitly mention when not to use this tool or compare with search_transcripts.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_episodesSearch the SGU archive (local index)A
Fast, bm25-ranked full-text search over the LOCAL archive of episode transcripts (the indexed .md corpus). Prefer this over search_transcripts for general questions — it's instant, offline, and ranked, and it returns highlighted snippets with episode metadata. Optionally restrict to a field: 'transcript' (default scope is all), 'news' (news-item titles), or 'title'. Falls back with a note if the index hasn't been built yet (run npm run setup or npm run fetch && npm run index).
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query. Supports MediaWiki/SQLite FTS syntax: phrases in quotes, AND/OR, prefix* | |
| limit | No | Max results (default 10) | |
| field | No | Restrict search to one field |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, but description discloses return of 'highlighted snippets with episode metadata', offline nature, and fallback if index missing. No contradictory or missing behavioral info.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two dense sentences: front-loaded with key purpose and comparison, then details on parameters and fallback. No extraneous words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema, description adequately covers return type (snippets, metadata). Explains parameters, fallback behavior, and differentiation from sibling. Complete for a search tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers all parameters, but description adds value by explaining query syntax (MediaWiki/SQLite FTS), default scope, and purpose of 'field' enum values. Extra detail beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it performs 'bm25-ranked full-text search' over the 'LOCAL archive of episode transcripts'. It distinguishes from the sibling 'search_transcripts' by noting it's 'instant, offline, and ranked'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly advises to 'Prefer this over search_transcripts for general questions' and explains why. Does not enumerate all exclusions but provides clear context on when to use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_news_itemsSearch SGU news itemsA
Search the science news items the show has covered. Each news item is its own topic page tagged with the episode number. Returns topic title, episode number, and link. Use to find which episode covered a topic, or to survey coverage of a subject.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Topic search terms | |
| limit | No | Max results (default 10) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, but description adequately discloses read-only search behavior, return format, and that each news item is linked to an episode. Does not mention pagination or sorting, but these are minor gaps given the simplicity. No contradictions.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two efficient sentences plus a concise return fields note. No unnecessary words. Front-loaded with action and scope.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple search tool with two parameters, the description provides complete information: purpose, usage, and return fields. No output schema, but return fields are listed. Fully adequate for agent invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with clear parameter descriptions. Description adds no additional detail beyond schema, so baseline score of 3 is appropriate. The parameter semantics are fully captured in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it searches science news items, each a topic page tagged with episode number. Distinguishes from sibling tools like search_episodes and search_transcripts by specifying the resource type and return fields (topic title, episode number, link).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly provides usage scenarios: 'find which episode covered a topic' and 'survey coverage of a subject.' Implicitly distinguishes from alternatives by focusing on news items. Could be improved by explicitly stating when not to use it (e.g., for episode search).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_segmentsSearch SGU segments (timecoded)A
Fine-grained full-text search over individual speaker turns in the local archive. Unlike search_episodes (which returns whole episodes), this returns the exact moments — each result has the episode, date, segment/section, the timestamp to jump to, the speaker, and a highlighted snippet. Use for 'find the moment when…', quoting who said what, or narrowing within an episode. Optional filters: episode, speaker (e.g. 'Steve', 'Cara'), year.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search terms (FTS syntax supported: phrases, AND/OR, prefix*) | |
| limit | No | Max results (default 10) | |
| episode | No | Restrict to one episode | |
| speaker | No | Restrict to a speaker, e.g. 'Steve', 'Bob', 'Cara' | |
| year | No | Restrict to a year, e.g. '2024' |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It describes a read-only search operation but does not explicitly state it is non-destructive or safe. It lacks disclosure about result ordering, pagination, or performance implications, which are typical for search tools.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is four sentences, front-loaded with purpose, then contrast, use cases, and optional filters. Every sentence adds value without redundancy. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a 5-parameter, 1-required tool with no output schema, the description is nearly complete. It explains the function, return fields, and filters. Missing are details about result sorting, default behavior, or any limitations, but overall sufficient for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already documents parameters well. The description adds minor context (e.g., speaker examples 'Steve', 'Cara') but does not significantly enhance understanding beyond the schema. Baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states this is a fine-grained full-text search over individual speaker turns, contrasting with search_episodes which returns whole episodes. It lists specific return fields (episode, date, segment, timestamp, speaker, snippet), making the tool's purpose and output unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly tells when to use this tool ('find the moment when…', quoting, narrowing within an episode) and contrasts it with search_episodes. It mentions optional filters but does not specify when not to use or other alternatives among the 12 sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_transcriptsSearch SGU transcriptsA
Full-text search across all SGU episode transcripts and topic pages on sgutranscripts.org. Use for questions like 'every time they discussed CRISPR' or 'what did they say about cold fusion'. Returns matching pages with snippets, the episode number, and a wiki URL.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search terms (MediaWiki full-text search syntax supported) | |
| limit | No | Max results (default 10) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It discloses return format (pages with snippets, episode number, wiki URL) and source (transcripts and topic pages). Does not mention potential side effects or limitations, but read-only nature is clear.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two front-loaded sentences: first defines scope, second provides examples and output structure. Every sentence adds value with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite missing output schema, description fully explains return fields (pages with snippets, episode number, wiki URL). For a simple search tool with two parameters, this is complete and avoids ambiguity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema covers both parameters with descriptions; description adds context that query supports MediaWiki syntax and that limit defaults to 10, which exceeds schema info. Baseline 3 due to 100% coverage, but value added justifies 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'Full-text search across all SGU episode transcripts and topic pages' with specific verb and resource. It gives example queries and output details, clearly distinguishing from siblings like search_episodes or semantic_search.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides example use cases ('every time they discussed CRISPR'), implying appropriate queries, but lacks explicit guidance on when not to use or how it differs from similar siblings like search_episodes or search_segments.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
semantic_searchSemantic search SGU episodesA
Concept-level search that finds episodes by meaning, not just keywords — ask in natural language (e.g. 'episodes about the ethics of de-extinction' or 'when they got frustrated with science denial'). Blends vector similarity with keyword (BM25) ranking via reciprocal-rank fusion. Returns episodes with title, date, theme, and a fused relevance score. Requires the embedding index (npm run embed); the provider is set by EMBED_PROVIDER (default 'local', no API key). Prefer search_episodes/search_segments for exact words; use this for fuzzy, conceptual questions.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | A natural-language description of what you're looking for | |
| limit | No | Max episodes (default 10) | |
| mode | No | hybrid (default) blends vector + keyword; semantic = vectors only; keyword = BM25 only |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description carries full burden. It explains the hybrid ranking approach (vector + keyword via RRF), the requirement of an embedding index, and the default provider. However, it does not detail failure modes (e.g., if index missing) or edge cases, leaving some behavioral gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (5 sentences) with the key purpose front-loaded. Every sentence adds distinct value: purpose, usage alternatives, algorithm overview, prerequisites, and configuration. No redundancy or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (hybrid search with 3 parameters and a prerequisite index), the description covers purpose, usage, parameters, and prerequisites adequately. It mentions return fields (title, date, theme, score) but lacks detailed return structure or error handling. Still, it is complete enough for an experienced agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds value by providing natural language examples for 'query', explaining default 'limit' (10), and describing 'mode' options with clear interpretations. This goes beyond the schema's basic descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it performs concept-level semantic search on episodes, using natural language queries. It explicitly distinguishes itself from sibling tools that search for exact words (search_episodes/search_segments), making its purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool ('for fuzzy, conceptual questions') and when to prefer alternatives ('prefer search_episodes/search_segments for exact words'). It also mentions a prerequisite (embedding index) and configuration (EMBED_PROVIDER), aiding correct invocation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TDQS
Each tool has a clearly distinct purpose. Tools like get_episode, get_episode_markdown, and get_transcript serve different retrieval needs; search tools are differentiated by scope and method (full-episode vs. segment, keyword vs. semantic). Descriptions further clarify overlap.
All tool names follow a consistent verb_noun pattern using snake_case (e.g., get_episode, search_segments). The convention is uniform across all 12 tools, enhancing predictability.
12 tools is well-scoped for a podcast archive and search server. It covers browsing, detailed retrieval, multiple search strategies, and statistics without being bloated or sparse.
The tool set covers core operations: episode retrieval, transcript access, various searches, and mention counting. A minor gap is the lack of a direct 'list all episodes' tool, but search tools can compensate.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Augments MCP Server - A comprehensive framework documentation provider for Claude Code
Hosted MCP server connecting claude.ai, ChatGPT and other AI apps to your own computer
An MCP server that provides tools to discover and retrieve podcast episodes transcripts.
Hosted MCP server for live public-data APIs and Skills for AI agents.
Related MCP Servers
- AlicenseDqualityDmaintenanceMCP server that provides Claude AI assistants with the ability to search the web, get news, and perform research using the You.com API.42MIT
- FlicenseAqualityDmaintenanceAn MCP server that scrapes and transcribes podcast episodes from YouTube or RSS feeds using Deepgram's Nova-2 model. It allows users to track podcasts for new episodes, manage transcripts, and generate personalized summaries through Claude.101
- FlicenseAqualityCmaintenanceMCP server that exposes Discord and Twitch/Chatty chat log query tools to Claude Code, enabling searching messages, channel stats, user messages, and events from chat logs.7
- AlicenseNot gradedqualityCmaintenanceAn MCP server that lets Claude answer ARK: Survival Ascended / Evolved questions by querying the ARK community wiki for taming, crafting, spawns, and stats.MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/matthewnigelgillet-cloud/sgu-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server