Entra.Chat Podcast MCP Server
Search and explore Merill Fernando's Entra.Chat podcast transcripts, guests, and community tool discussions with timestamped YouTube links.
search_entra_podcasts: Search all episode transcripts using hybrid (BM25 + semantic), semantic, or keyword mode; returns excerpts, episode metadata, guests, and timestamped YouTube links.get_episode: Retrieve a full episode by video ID, episode number, or date — metadata, guests with profiles, chapters, and complete transcript with time markers.list_episodes: Browse the archive, filtered by year, month, or guest, with pagination.list_guests: View a directory of all podcast guests with profile links, appearance counts, and latest appearance dates.get_guest: Look up a specific guest by name (partial matches work) to get their profile links and every episode they appeared on.find_tool_mentions: Discover community tools and open-source projects discussed on the show, with timestamped links, optionally filtered by keyword.
Click on "Deploy 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., "@Entra.Chat Podcast MCP ServerWhat did Merill and guests say about PIM for Groups?"
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.
Entra.Chat Podcast MCP Server
An MCP (Model Context Protocol) server for searching transcripts of Entra.Chat — Merill Fernando's Microsoft Entra podcast on YouTube. Ask your AI assistant about Entra ID features, community tools, and identity topics discussed on the show, and get answers with timestamped YouTube links that jump straight to the relevant moment.
Companion to entra-news-mcp (the written Entra.News newsletter archive) and microsoft-ai-roundup-mcp.
How it works
Zero per-user infrastructure. Install via NPX; the transcript database (SQLite) is downloaded automatically from this repo's GitHub Releases on first run and cached locally (
~/.entra-news-podcast-mcp/). Updates are checked weekly.Hybrid retrieval. BM25 keyword search (in-memory inverted index with Porter stemming — ideal for exact names like "PIM for Groups" or "Maester" in messy spoken-word transcripts) fused with OpenAI semantic vector search via Reciprocal Rank Fusion. No API key? Keyword search works out of the box.
Timestamped deep links. Every search result links to
youtube.com/watch?v=...&t=...so you can hear the discussion in context.Guest knowledge. Guests are extracted per episode with their profile links (LinkedIn, Twitter/X, GitHub, Bluesky) — ask "which episodes was X on?" or "who has been on the show?".
Fresh weekly. A GitHub Action re-ingests the playlist every week and publishes an updated database release.
Related MCP server: Entra News MCP Server
Installation
Requires Node.js 22+ (uses the built-in node:sqlite — no native dependencies).
Claude Desktop
Add to claude_desktop_config.json:
{
"mcpServers": {
"entra-podcasts": {
"command": "npx",
"args": ["-y", "entra-news-podcast-mcp"],
"env": {
"OPENAI_API_KEY": "sk-..."
}
}
}
}The OPENAI_API_KEY is optional — it enables semantic/hybrid search (embedding the query costs a fraction of a cent). Without it, BM25 keyword search is used.
Claude Code
claude mcp add entra-podcasts -- npx -y entra-news-podcast-mcpVS Code (GitHub Copilot)
{
"servers": {
"entra-podcasts": {
"command": "npx",
"args": ["-y", "entra-news-podcast-mcp"]
}
}
}Cursor
{
"mcpServers": {
"entra-podcasts": {
"command": "npx",
"args": ["-y", "entra-news-podcast-mcp"]
}
}
}Tools
Tool | Description |
| Search all episode transcripts. Modes: |
| Full episode by |
| Browse the archive; filter by |
| Directory of all podcast guests with profile links, appearance counts, and latest appearance. |
| One guest by name: profile links and every episode they appeared on. |
| Community tools discussed on the show, with timestamped links to hear the discussion. |
Example prompts
"What did Merill and his guests say about PIM for Groups?"
"Which episodes has Jane Doe been on? What's her LinkedIn?"
"Find where Maester was discussed and give me the YouTube timestamp."
"List the Entra.Chat episodes from March 2026."
Data & freshness
Source | Entra.Chat playlist on YouTube (@merillx) |
Transcripts | YouTube captions (uploaded captions preferred, auto-generated otherwise) |
Refresh | Weekly GitHub Action → new |
Local cache |
|
Runtime override | Set |
Development
npm install
npm run build
# Ingest (requires yt-dlp on PATH: pipx install yt-dlp / winget install yt-dlp)
node dist/scripts/ingest.js --limit 2 # test with 2 videos
node dist/scripts/ingest.js # full playlist backfill
node dist/scripts/ingest.js --incremental # only new videos
node dist/scripts/ingest.js --video <id> # one video (re-ingests)
node dist/scripts/ingest.js --reextract # rebuild guests + tool mentions from stored
# data (no network) — after editing
# guest-overrides.json or known-tools.ts
node dist/scripts/ingest.js --embed-missing # embed chunks that have no embedding yet
# (needs OPENAI_API_KEY; no YouTube access)
# Run the server against a local DB
ENTRA_PODCAST_DB_PATH=./entra-news-podcasts.db npx @modelcontextprotocol/inspector node dist/src/index.jsSet OPENAI_API_KEY during ingest to generate embeddings (semantic search); without it the ingest still completes and BM25 keyword search works.
Guest extraction overrides
Guests are extracted heuristically from video titles/descriptions. Episodes the heuristics miss are listed at the end of each ingest run — correct them in scripts/lib/guest-overrides.json (keyed by video_id, entries fully replace extraction for that video) and apply with node dist/scripts/ingest.js --reextract (no re-download needed).
PO token provider (yt-dlp caption downloads)
YouTube's caption/timedtext endpoint returning 429 has (at least) two distinct, unrelated causes — the ingest log's CAPTION_RATE_LIMITED error can't tell you which from the message text alone:
No PO (Proof-of-Origin) token supplied for the
web/web_safariclients yt-dlp uses by default — see the yt-dlp PO Token Guide.The video has multiple audio/dub tracks and resolved to the translated caption bucket rather than a native
<lang>-origtranscript — seepickCaptionLanguageinscripts/lib/ytdlp.ts. Confirmed 2026-09-09: this still 429s even with a working PO token provider.
Regardless of source IP — confirmed 2026-09-09 by reproducing the identical failure from four different exit IPs (two IPRoyal residential identities in two countries, plus a clean home residential IP with no proxy at all). A proxy does not fix either cause.
CI sets up the PO token provider automatically (.github/workflows/weekly-update.yml, "Set up PO token provider" step, version-pinned — see that step's comment). For local ingest runs, set it up once:
# 1. Provider (script mode — spawns per request, no persistent server needed).
# The server (git tag) and plugin (PyPI package, step 2) are separately
# versioned and must match — check the pinned version in
# .github/workflows/weekly-update.yml ($BGUTIL_VERSION) rather than
# grabbing "latest" for one and not the other.
git clone --single-branch --branch 2.0.0 \
https://github.com/Brainicism/bgutil-ytdlp-pot-provider.git \
~/bgutil-ytdlp-pot-provider # %USERPROFILE%\bgutil-ytdlp-pot-provider on Windows — this exact path, yt-dlp looks here by default
cd ~/bgutil-ytdlp-pot-provider/server
npm ci
npx tsc
# 2. Plugin — install into the SAME Python env yt-dlp itself runs under
# (check with `python -c "import sys; print(sys.executable)"` vs `yt-dlp` on
# PATH — a mismatch here is a common trap and yt-dlp will silently not see
# the plugin). If yt-dlp was installed via pipx: `pipx inject yt-dlp bgutil-ytdlp-pot-provider==2.0.0`
python3 -m pip install -U bgutil-ytdlp-pot-provider==2.0.0
# Verify a WORKING provider — not just a listed one. yt-dlp lists an entry
# even when it's unusable, suffixed "(external, unavailable)"; a real one
# reads "(external)" with nothing else in the parens.
yt-dlp -v --skip-download --simulate "https://www.youtube.com/watch?v=jNQXAC9IVRw" 2>&1 \
| grep -E "bgutil:script-(node|deno)-[0-9.]+ \(external\)"Manual database refresh (if YouTube blocks CI)
YouTube sometimes blocks general page/API requests from datacenter IPs (BOT_BLOCKED in the workflow log — distinct from CAPTION_RATE_LIMITED above, which is captions-specific and not IP-related). Consumers are unaffected either way — the last-good release stays latest.
Mitigations built in before falling back to a manual refresh:
CI installs Deno, which yt-dlp requires as a JS runtime to solve YouTube's player challenges — without it, requests are far more likely to be flagged as bot traffic.
The
YTDLP_PROXYrepository secret (set since 2026-07-21 to a residential proxy URL inhttp://user:pass@host:portform — note IPRoyal's dashboard showshost:port:user:pass, which must be rewritten, and geo-targeting modifiers like_country-au_city-hurstvilleare appended to the password, not the username) routes all yt-dlp traffic through that proxy. The same env var works for local ingest runs. This only helps withBOT_BLOCKED, notCAPTION_RATE_LIMITED.
If CI is still blocked, refresh manually from a residential IP (set up the PO token provider above first):
node dist/scripts/ingest.js --incremental
gh release create "db-$(date -u +%Y.%m.%d)-9999" \
--repo darrenjrobinson/EntraNewsPodcastMCPServer \
--title "Database Update (manual)" --latest \
./entra-news-podcasts.dbRelease process (maintainer)
Code releases (v* tags) publish to npm (Trusted Publishing / OIDC, no tokens) and the MCP Registry (io.github.darrenjrobinson/entra-news-podcast) via .github/workflows/publish-mcp.yml:
Bump
versioninpackage.jsonand both version fields inserver.json(CI enforces lockstep).Commit, then
git tag v0.x.y && git push origin main v0.x.y.
Database releases (db-* tags) are produced by the weekly workflow and never trigger an npm publish.
License
MIT © Darren Robinson
Available Tools
6 toolsfind_tool_mentionsA
Find community tools and open-source projects discussed on Entra.Chat episodes. Returns tool names, the episodes where they were discussed, and timestamped YouTube links to hear the discussion. Optionally filter by keyword.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of tool mentions to return (default: 20) | |
| query | No | Optional filter — search by tool name or keyword (e.g. "Maester", "PowerShell", "Conditional Access") |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It discloses the read-only nature ('Find', 'Returns') and specifies the output content (tool names, episode references, YouTube links). It does not mention pagination or ordering, but for a simple lookup tool this is adequate and adds value beyond the schema.
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, front-loaded with the core purpose and return value, with no filler. Every phrase adds value, and the optional filter is mentioned succinctly.
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 two-parameter search tool with no output schema, the description fully explains what to expect: results include tool names, episodes, and timestamped YouTube links. It is self-contained and sufficient for an agent to invoke 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%, with both limit and query fully documented, so the description does not need to compensate. The description only reiterates the optional keyword filter, adding no extra semantic detail beyond the schema examples.
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 uses a specific verb ('Find') with a clear resource ('community tools and open-source projects discussed on Entra.Chat episodes') and explicitly states what it returns (tool names, episodes, timestamped links). This differentiates it from sibling tools like search_entra_podcasts, which likely handle broader podcast 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?
The description provides clear context for when to use the tool: to locate tool mentions across episodes, with an optional keyword filter. It does not explicitly name alternatives or exclusions, but the purpose is distinct enough that an agent can infer when to select it over siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_episodeA
Retrieve a specific Entra.Chat episode by YouTube video ID or publication date. Returns full metadata (guests with profile links, chapters with timestamped links) and the complete transcript with [mm:ss] time markers.
| Name | Required | Description | Default |
|---|---|---|---|
| date | No | Date in YYYY-MM-DD or YYYY-MM format to find the nearest episode (e.g. "2026-03" or "2026-03-15") | |
| video_id | No | YouTube video ID (11 characters) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. 'Retrieve' implies a read-only operation and it describes the return contents, but it does not address permissions, rate limits, pagination, or error behavior. It adds useful output context but only partially covers behavioral traits.
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, front-loaded with the core action and identifiers, then the return contents. Every sentence earns its place and there is no filler.
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 low-complexity retrieval tool with rich schema descriptions, the definition is complete. It explains the return payload even though no output schema exists, and the input semantics are covered by the schema.
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 description coverage is 100%, so the schema already documents both parameters in detail. The description adds that the lookup can be by video ID or publication date, but this is largely redundant with the schema 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 states a specific verb and resource: retrieve a specific Entra.Chat episode. It clearly distinguishes itself from list/search siblings by emphasizing a single episode identified by video ID or publication date.
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 gives clear context for when to use it: when you have a YouTube video ID or publication date for a specific episode. However, it does not explicitly name alternatives such as list_episodes or search_entra_podcasts 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_guestA
Get a specific Entra.Chat guest by name: their profile links (LinkedIn, Twitter/X, GitHub, Bluesky, website) and every episode they appeared on, enumerated with episode number, title, date, and URL. Partial names match; returning guests show all their appearances.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Guest name to look up (case-insensitive; partial names match) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of explaining behavior. It discloses that partial names match, that returning guests show all their appearances, and enumerates the exact fields returned. It does not mention error handling or auth, but the read-only nature is clear from 'Get'.
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 a single focused sentence that front-loads the core purpose before detailing the return contents. Every clause adds useful information, with no filler or 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?
For a one-parameter lookup with no output schema, the description does a good job of specifying the return structure: profile links and episode details (number, title, date, URL). It omits edge-case behavior like multiple partial matches, but overall it gives an agent enough context to understand what the tool returns.
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 already describes the 'name' parameter well (case-insensitive, partial names match), and the description mostly restates this. High schema coverage means the description adds little beyond what is already in the input schema, 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 opens with a specific verb and resource: 'Get a specific Entra.Chat guest by name.' It clearly distinguishes this from sibling tools like list_guests or get_episode by focusing on a single guest and describing the exact return payload (profile links and episode appearances).
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 implies the tool is for targeted guest lookups ('specific guest by name') and notes that partial names match, but it does not explicitly contrast with alternatives such as list_guests or search_entra_podcasts. There is no when-to-use or when-not-to-use guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_episodesA
Browse the Entra.Chat episode archive with optional year/month/guest filtering. Returns title, date, duration, guests, and URL. Use this to discover what episodes exist before using get_episode or search_entra_podcasts.
| Name | Required | Description | Default |
|---|---|---|---|
| year | No | Filter by year (e.g. 2026) | |
| guest | No | Filter to episodes featuring a guest whose name contains this text | |
| limit | No | Maximum episodes to return (default: 50) | |
| month | No | Filter by month number 1–12 (e.g. 3 for March). Requires year. | |
| offset | No | Pagination offset (default: 0) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden; it discloses the return fields (title, date, duration, guests, URL), which helps. However it says nothing about pagination defaults/total counts, result caps, or auth needs, and those behaviors are only implied by the schema. Adequate but not rich given zero annotation coverage.
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 tightly written sentences with zero waste: purpose and filters first, return payload second, routing guidance last. Nothing redundant or padded.
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 read/list tool with full schema coverage, the description covers purpose, filters, and return shape, which is what the agent needs. It omits any mention of pagination behavior, but since limit/offset are self-documented in the schema and no output schema exists, the gap is minor.
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 description coverage is 100%, so year/month/guest/limit/offset are already fully documented in the schema. The description restates the filtering dimensions (year/month/guest) but adds no syntax or format detail beyond what the schema already gives, so the baseline 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?
States a specific verb and resource ("Browse the Entra.Chat episode archive") plus the filterable dimensions, and names the sibling tools (get_episode, search_entra_podcasts) it is distinct from. An agent can tell this is the enumeration tool versus the retrieval/search tools without opening any schema.
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 routes the agent: "Use this to discover what episodes exist before using get_episode or search_entra_podcasts." It gives clear context and names alternatives, but does not explain when to prefer search_entra_podcasts over this list tool (e.g. for keyword lookups), so the boundary between the two discovery paths is left to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_guestsA
Browse the directory of Entra.Chat podcast guests. Returns each guest with profile links (LinkedIn, Twitter/X, GitHub, Bluesky, website), how many episodes they appeared on, and their latest appearance date. Use get_guest for a full per-guest episode list.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum guests to return (default: 50, max: 200) | |
| query | No | Optional filter — only guests whose name contains this text | |
| offset | No | Pagination offset (default: 0) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly explains what the tool returns and implies a read-only nature via 'Browse.' It also indicates the tool does not provide full episode lists, directing to get_guest for that. The description does not explicitly mention side effects, but for a directory listing tool, the behavior is well-understood and clearly described.
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 three sentences, each earning its place. The first sentence states the purpose, the second details the return contents, and the third provides a pointer to an alternative. It is front-loaded with the primary purpose and contains no 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 that there is no output schema, the description appropriately explains the return structure (profile links, episode count, latest appearance). It also covers the tool's scope and directs users to a sibling tool for more detail. The input schema handles parameter documentation, and the description provides the necessary context for a listing tool. The tool is simple enough that this description is complete.
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 description coverage is 100%, so the baseline is 3. The description does not add any parameter-specific meaning beyond what the input schema already provides. The parameters (limit, query, offset) are fully described in the schema, and the description focuses on the return structure rather than parameter details. No additional value is added here.
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's purpose: 'Browse the directory of Entra.Chat podcast guests.' It specifies the resource (guest directory), the verb (browse), and the return structure (profile links, episode counts, latest appearance). It also distinguishes itself from the sibling tool get_guest by directing users there for full per-guest episode lists.
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 versus an alternative: 'Use get_guest for a full per-guest episode list.' It implies that this tool is for browsing the directory and getting summary information, and it gives a clear pointer for a more detailed need. However, it doesn't explicitly discuss other siblings like search_entra_podcasts or list_episodes, but the context is sufficient for most use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_entra_podcastsA
Search transcripts of the Entra.Chat podcast (Merill Fernando's Microsoft Entra podcast on YouTube) using natural language or keywords. Returns transcript excerpts with episode metadata, guest names, and timestamped YouTube deep links that start playback at the relevant moment. Hybrid mode fuses BM25 keyword search with semantic vector search via Reciprocal Rank Fusion (semantic requires OPENAI_API_KEY; keyword works with no configuration).
| Name | Required | Description | Default |
|---|---|---|---|
| mode | No | Search mode: hybrid (default), semantic-only, or keyword-only (BM25) | hybrid |
| limit | No | Maximum number of results to return (default: 10, max: 50) | |
| query | Yes | Natural language question or keywords to search for |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden and does well: it discloses the hybrid fusion algorithm (Reciprocal Rank Fusion), the external dependency (OPENAI_API_KEY), and the nature of responses (excerpts, metadata, deep links). It does not cover fallback behavior when the API key is missing or any error/rate-limit behavior, but for a read-only search tool this is acceptable 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?
Three sentences, no fluff. The first sentence states the action and resource, the second describes the return values and search algorithms, and the third provides configuration guidance. Every sentence contributes, and key information is front-loaded.
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?
The description covers the tool's purpose, output contents, mode behavior, and dependencies. It lacks a precise output schema (none provided) but gives enough detail that an agent can infer what to expect. It does not explicitly say it searches across all episodes, but that is implied. Overall, it is adequate for the tool's complexity.
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 real value by explaining what hybrid mode does (BM25 + semantic via RRF) and the API key requirement for semantic mode. This exceeds simple schema labels and helps the agent choose the right mode.
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 opens with 'Search transcripts of the Entra.Chat podcast' — a specific verb and resource. It clearly distinguishes from siblings (get_episode, list_episodes, list_guests, find_tool_mentions) by focusing on cross-transcript search. It also enumerates the output: excerpts, episode metadata, guest names, and timestamped deep links.
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 clarifies when to use this tool: for natural language or keyword search over transcripts. It explains the three modes (hybrid, semantic, keyword) and gives practical guidance — semantic requires OPENAI_API_KEY, keyword works with none. It does not explicitly contrast with sibling tools, but the purpose and sibling names imply the distinction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
1 tool update
v0.1.5- Changed
get_episode1 field changed- removed
Input schema / properties / episode_numberRemoved value: -{ - "description": "Episode number (e.g. 12)", - "type": "number" -}
6 tool updates
v0.1.2- First observed
find_tool_mentions - First observed
get_episode - First observed
get_guest - First observed
list_episodes - First observed
list_guests - First observed
search_entra_podcasts
TDQS
Scored across 6 tools
Each tool has a largely distinct purpose: listing vs. getting episodes and guests, plus a dedicated tool-mention finder. The only mild overlap is between search_entra_podcasts and find_tool_mentions, since a general transcript search could also surface tool discussions, but the descriptions make the intended scope clear.
The set follows a clear verb_noun pattern (get_episode, list_episodes, get_guest, list_guests, find_tool_mentions). search_entra_podcasts is the one deviation, embedding the domain name where others don't, but it remains readable and predictable.
Six tools is well-scoped for a podcast archive: browse/list and fetch/get for both episodes and guests, plus transcript search and a tool-mention finder. Every tool earns its place with no redundancy.
The surface covers episode discovery, retrieval, transcript search, guest profiles, and community tool mentions, which is thorough for this domain. Minor gap: no explicit full tool/project directory separate from keyword-filtered find_tool_mentions, but this is workable.
Maintenance
Related MCP Connectors
Search indexed YouTube and podcast transcripts. Full transcripts, mentions, momentum, and sponsors.
Search 4M+ podcasts & YouTube, transcribe any episode, search transcripts, generate AI lessons.
Search and analyze 50,000+ hours of business podcast transcripts, entities, and speakers.
YouTube transcripts, search, channel/playlist listings and upload tracking for AI agents. No signup.
Related MCP Servers
- FlicenseBqualityDmaintenanceEnables interaction with YouTube through search and transcript extraction functionality. Allows searching for videos and retrieving full transcripts with timestamps for content analysis.27-
- AlicenseAqualityAmaintenanceProvides a searchable knowledge base over the Entra.news archive, enabling natural language queries for Microsoft Entra announcements, features, and community tools. Users can perform hybrid semantic searches, retrieve specific newsletter issues, and discover mentioned GitHub projects or PowerShell tools.455 npm7MIT
- AlicenseAqualityDmaintenanceEnables AI assistants to fetch YouTube video transcripts with precise timestamps, multi-language support, and time-range filtering.31MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to search and retrieve meeting transcripts from Otter.ai, supporting full-text search, speaker identification, and transcript retrieval.5MIT