Fed Speech MCP
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., "@Fed Speech MCPfind recent speeches by Powell about inflation"
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.
Fed Speech MCP
An MCP (Model Context Protocol) server that retrieves, parses, and analyzes speeches and testimonies from major Federal Reserve officers.
Features
š” RSS Feed Discovery - Automatically discovers new speeches from Fed RSS feeds
š Index Page Scanning - Backfill capability by scanning yearly index pages
š Smart Parsing - Extracts metadata, speaker info, and clean text from Fed HTML pages
š Feature Extraction - Detects topics (inflation, rates, labor market, etc.)
āļø Importance Scoring - Rule-based scoring for market relevance
š¾ JSON Storage - Persistent storage with deduplication
š MCP Interface - Full MCP compatibility for AI assistants
Related MCP server: harness-feed-mcp
Covered Content
Speakers
Chair of the Federal Reserve
Vice Chair of the Federal Reserve
Federal Reserve Governors
Content Types
Speeches
Congressional Testimony
Prepared Remarks
Installation
Prerequisites
Python 3.10 or higher
uv package manager
Install uv (if you don't have it):
# macOS / Linux
curl -LsSf https://astral.sh/uv/install.sh | sh
# Windows
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"Install the Project
cd fed-speech-mcp
# Create virtual environment and install
uv syncThat's it! The virtual environment is created and all dependencies are installed.
š Quick Start: Test Locally in 5 Minutes
Want to see the MCP tools in action before connecting to an AI? Follow these steps:
Step 1: Install
cd fed-speech-mcp
uv syncStep 2: Fetch Speeches from Fed Website
uv run python scripts/test_local.py refresh --limit 5You'll see output like:
š REFRESHING SPEECHES FROM FED WEBSITE
==================================================
š” Discovering documents via RSS feeds...
Found 20 document(s)
[1/5] Processing: Governor Bowman's Speech on Banking...
ā
Fetched 45231 bytes
ā
Parsed: Michelle W. Bowman - speech
ā
Normalized: fed-speech-a1b2c3d4e5f6
ā
Saved (NEW)
...
ā
REFRESH COMPLETE
Discovered: 5
New: 5
Total in storage: 5Step 3: Explore the Data
View latest speeches:
uv run python scripts/test_local.py latest --limit 3Output:
š° LATEST SPEECHES
==================================================
Found 3 speech(es):
1. Speech on Monetary Policy and the Economic Outlook
š
2024-12-15
š¤ Jerome H. Powell (Chair)
š speech | 2500 words
ā high (0.85)
š·ļø Topics: inflation, rates, labor
š https://federalreserve.gov/...
š fed-speech-abc123Search by keyword:
uv run python scripts/test_local.py search --query "inflation"Filter by speaker:
uv run python scripts/test_local.py speaker --name "Powell"
uv run python scripts/test_local.py speaker --role "Chair"Get full speech content:
uv run python scripts/test_local.py get --doc-id fed-speech-abc123View statistics:
uv run python scripts/test_local.py statsStep 4: Run All Tests
uv run python scripts/test_local.py allThis runs a complete test suite: refresh ā stats ā latest ā search ā filter ā get.
Available Test Commands
Command | Description | Example |
| Fetch new speeches |
|
| Show latest speeches |
|
| Search by keyword |
|
| Filter by speaker |
|
| Filter by doc type |
|
| Get full speech |
|
| Show statistics | (no options) |
| Run all tests | (no options) |
Using with AI Assistants
Platform Compatibility Overview
Platform | MCP Support | Setup Method |
Claude Desktop | ā Native | Direct MCP integration |
Cursor IDE | ā Native | Direct MCP integration |
ChatGPT | ā ļø Via API | HTTP API wrapper + Custom GPT |
Google Gemini | ā ļø Via API | HTTP API wrapper + Google AI Studio |
Other AI Tools | ā ļø Via API | HTTP API wrapper |
Step-by-Step: Claude Desktop
Claude Desktop has native MCP support. This is the easiest setup.
Step 1: Install the Package
cd fed-speech-mcp
uv syncStep 2: Locate Claude Desktop Config
macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.json
Step 3: Add MCP Server Configuration
Edit claude_desktop_config.json:
{
"mcpServers": {
"fed-speech": {
"command": "uv",
"args": ["run", "fed-speech-mcp"],
"cwd": "/path/to/fed-speech-mcp"
}
}
}Note: Replace
/path/to/fed-speech-mcpwith your actual installation path.
Step 4: Restart Claude Desktop
Close and reopen Claude Desktop. You should see the Fed Speech tools available.
Step 5: Start Using
Ask Claude things like:
"Refresh the Fed speeches and show me the latest ones"
"What did Chair Powell say about inflation recently?"
"Show me all testimony from 2024"
Step-by-Step: Cursor IDE
Cursor IDE also supports MCP natively.
Step 1: Install the Package
cd fed-speech-mcp
uv syncStep 2: Open Cursor Settings
Open Cursor IDE
Go to Settings (ā+, on macOS, Ctrl+, on Windows)
Search for "MCP" or navigate to Features ā MCP Servers
Step 3: Add MCP Server
Click "Add MCP Server" and configure:
{
"name": "fed-speech",
"command": "uv",
"args": ["run", "fed-speech-mcp"],
"cwd": "/path/to/fed-speech-mcp"
}Step 4: Enable and Use
Toggle the server on. You can now use Fed Speech tools in Cursor's AI chat.
Step-by-Step: ChatGPT (Custom GPT)
ChatGPT doesn't support MCP natively, but you can use the HTTP API wrapper.
Step 1: Install the Package
cd fed-speech-mcp
uv syncStep 2: Start the HTTP API Server
uv run fed-speech-httpThe server runs at http://localhost:8000 by default.
Step 3: Expose to Internet (Required for ChatGPT)
Use a tunneling service like ngrok:
# Install ngrok: https://ngrok.com/download
ngrok http 8000Copy the public URL (e.g., https://abc123.ngrok.io).
Step 4: Create a Custom GPT
Go to ChatGPT
Click your profile ā My GPTs ā Create a GPT
In the Configure tab:
Name: "Fed Speech Analyst"
Description: "Analyzes Federal Reserve speeches and testimonies"
Instructions:
You are a Federal Reserve speech analyst. Use the available actions to: 1. Fetch latest speeches with get_latest_speeches 2. Search speeches by speaker, type, or keywords 3. Analyze speech content for market-relevant insights Always refresh speeches first if the user asks about recent content.
Click Create new action and import the OpenAPI schema:
openapi: 3.0.0
info:
title: Fed Speech API
version: 1.0.0
servers:
- url: https://your-ngrok-url.ngrok.io
paths:
/speeches/latest:
get:
operationId: getLatestSpeeches
summary: Get latest Fed speeches
parameters:
- name: limit
in: query
schema:
type: integer
default: 10
- name: since_date
in: query
schema:
type: string
responses:
'200':
description: List of speeches
/speeches/search:
get:
operationId: searchSpeeches
summary: Search speeches by keyword
parameters:
- name: query
in: query
required: true
schema:
type: string
- name: limit
in: query
schema:
type: integer
default: 10
responses:
'200':
description: Search results
/speeches/{doc_id}:
get:
operationId: getSpeech
summary: Get a specific speech
parameters:
- name: doc_id
in: path
required: true
schema:
type: string
responses:
'200':
description: Speech details
/speeches/refresh:
post:
operationId: refreshSpeeches
summary: Fetch new speeches from Fed website
responses:
'200':
description: Refresh resultStep 5: Save and Use
Save your Custom GPT. Now you can ask it questions about Fed speeches!
Step-by-Step: Google Gemini
Google Gemini can use the HTTP API via Google AI Studio or API.
Step 1: Start the HTTP API Server
cd fed-speech-mcp
uv sync
uv run fed-speech-httpStep 2: Expose to Internet
ngrok http 8000Step 3: Use with Google AI Studio
Go to Google AI Studio
Create a new prompt or chat
In your system instructions, include:
You have access to a Fed Speech API at https://your-ngrok-url.ngrok.io
Available endpoints:
- GET /speeches/latest?limit=10 - Get latest speeches
- GET /speeches/search?query=inflation - Search speeches
- GET /speeches/{doc_id} - Get specific speech
- POST /speeches/refresh - Fetch new speeches
- GET /speeches/by-speaker?name=Powell - Filter by speaker
- GET /speeches/by-type?doc_type=testimony - Filter by type
When users ask about Fed speeches, use these endpoints to fetch data.
Format responses clearly with speaker names, dates, and key points.Step 4: Use Function Calling (Advanced)
For programmatic use with Gemini API:
import google.generativeai as genai
import requests
# Configure Gemini
genai.configure(api_key="YOUR_API_KEY")
# Define tools for Gemini
tools = [
{
"function_declarations": [
{
"name": "get_latest_speeches",
"description": "Get the latest Federal Reserve speeches",
"parameters": {
"type": "object",
"properties": {
"limit": {"type": "integer", "description": "Max speeches to return"}
}
}
},
{
"name": "search_speeches",
"description": "Search Fed speeches by keyword",
"parameters": {
"type": "object",
"properties": {
"query": {"type": "string", "description": "Search query"}
},
"required": ["query"]
}
}
]
}
]
model = genai.GenerativeModel('gemini-pro', tools=tools)
# Handle function calls
def handle_function_call(fn_name, args):
base_url = "http://localhost:8000"
if fn_name == "get_latest_speeches":
resp = requests.get(f"{base_url}/speeches/latest", params=args)
elif fn_name == "search_speeches":
resp = requests.get(f"{base_url}/speeches/search", params=args)
return resp.json()
# Chat with function calling
chat = model.start_chat()
response = chat.send_message("What are the latest Fed speeches about inflation?")
# Process function calls in response
for part in response.parts:
if hasattr(part, 'function_call'):
fn = part.function_call
result = handle_function_call(fn.name, dict(fn.args))
# Send result back to model
response = chat.send_message(str(result))HTTP API Reference
When using the HTTP API wrapper, these endpoints are available:
Endpoint | Method | Description |
| GET | Get latest speeches |
| GET | Search by keyword |
| GET | Get specific speech |
| GET | Filter by speaker |
| GET | Filter by doc type |
| POST | Fetch new speeches |
| GET | Get statistics |
Query Parameters
limit- Max results (default: 10, max: 50)since_date- ISO 8601 date filterstart_date/end_date- Date rangename- Speaker name (partial match)role- "Chair", "Vice Chair", or "Governor"doc_type- "speech", "testimony", or "prepared_remarks"query- Search keywords
Running the MCP Server Directly
For native MCP clients:
# Run the MCP server
uv run fed-speech-mcp
# Run the HTTP API server
uv run fed-speech-httpAvailable Tools
get_latest_speeches
Get the latest Federal Reserve speeches, sorted by publication date.
Parameters:
limit(optional): Maximum number of speeches (default: 10, max: 50)since_date(optional): Only return speeches after this date (ISO 8601)
get_speeches_by_speaker
Filter speeches by speaker name and/or role.
Parameters:
name(optional): Speaker name (partial match, e.g., "Powell")role(optional): "Chair", "Vice Chair", or "Governor"start_date(optional): Start date filterend_date(optional): End date filter
get_speeches_by_type
Get speeches by document type.
Parameters:
doc_type(required): "speech", "testimony", or "prepared_remarks"start_date(optional): Start date filterend_date(optional): End date filter
get_speech
Get full content and metadata for a specific speech.
Parameters:
doc_id(required): The unique document identifier
refresh_speeches
Fetch new speeches from the Federal Reserve website.
Parameters:
include_index(optional): Also scan index pages (slower but thorough)years(optional): Years to scan for index pages
search_speeches
Search speeches by keyword.
Parameters:
query(required): Search querylimit(optional): Maximum results (default: 10)
get_speech_stats
Get statistics about stored speeches.
Output Format
Each speech document contains:
{
"doc_id": "fed-speech-abc123def456",
"source": {
"publisher": "Board of Governors of the Federal Reserve System",
"collection": "speeches",
"url": "https://www.federalreserve.gov/...",
"retrieved_at": "2024-01-15T10:30:00Z"
},
"published_at": "2024-01-15T00:00:00Z",
"title": "Speech Title",
"speaker": {
"name": "Jerome H. Powell",
"role": "Chair",
"organization": "Board of Governors of the Federal Reserve System"
},
"doc_type": "speech",
"event": {
"name": "Economic Club of New York",
"location": "New York, NY"
},
"text": {
"raw": "...",
"clean": "..."
},
"features": {
"word_count": 2500,
"language": "en",
"has_qa": false,
"topics": {
"inflation": true,
"labor_market": true,
"rates": true,
"balance_sheet": false,
"growth": true,
"financial_stability": false
}
},
"importance": {
"tier": "high",
"score": 0.85,
"reasons": [
"Speaker is Chair (Jerome H. Powell)",
"Discusses rates in context of inflation"
]
}
}Importance Scoring
The importance score is calculated using these rules:
Factor | Adjustment |
Chair or Vice Chair speaker | Base: High |
Governor speaker | Base: Medium |
Testimony | +1 tier |
Contains Q&A | +1 tier |
Discusses rates + (inflation or labor market) | +1 tier |
Word count < 300 | -1 tier |
Topic Detection
Topics are detected by keyword matching:
Inflation: inflation, prices, CPI, PCE, price stability
Labor Market: employment, unemployment, wages, jobs
Rates: interest rate, fed funds, hike, cut, monetary policy
Balance Sheet: QE, QT, runoff, asset purchases
Growth: GDP, demand, recession, economic activity
Financial Stability: banking, liquidity, stress, systemic risk
Environment Variables
Variable | Description | Default |
| Data storage directory |
|
| HTTP request timeout (seconds) |
|
| Max retry attempts |
|
| HTTP API server port |
|
Data Storage
data/
āāā speeches/ # Processed JSON documents
ā āāā fed-speech-xxx.json
ā āāā ...
āāā raw/ # Raw HTML content (for traceability)
āāā 20240115_abc123.html
āāā ...Development
Running Unit Tests
# Install with dev dependencies
uv sync --dev
# Run all tests
uv run pytest
# Run with verbose output
uv run pytest -v
# Run specific test file
uv run pytest tests/test_models.py
# Run with coverage
uv run pytest --cov=fed_speech_mcpRunning Local Integration Tests
# Test all MCP functionality end-to-end
uv run python scripts/test_local.py all
# Test specific functionality
uv run python scripts/test_local.py refresh --limit 3
uv run python scripts/test_local.py search --query "rates"Project Structure
fed-speech-mcp/
āāā src/fed_speech_mcp/
ā āāā __init__.py
ā āāā server.py # MCP server entry point
ā āāā http_server.py # HTTP API wrapper
ā āāā config.py # Configuration
ā āāā models/ # Pydantic data models
ā āāā ingestion/ # RSS/index discovery & fetching
ā āāā parsing/ # HTML parsing & normalization
ā āāā features/ # Feature extraction & scoring
ā āāā storage/ # JSON storage layer
āāā data/ # Data directory
āāā pyproject.toml
āāā README.mdLicense
MIT
Acknowledgments
Data sourced from the Federal Reserve Board.
Available Tools
7 toolsget_latest_speechesA
Get the latest Federal Reserve speeches. Returns speeches sorted by publication date, most recent first.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Maximum number of speeches to return (default: 10, max: 50) | |
| since_date | No | Only return speeches published on or after this date (ISO 8601 format, e.g., '2024-01-01') |
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 discloses that speeches are sorted by publication date (most recent first), which is useful behavioral context. However, it doesn't mention rate limits, authentication needs, error handling, or pagination behavior, leaving gaps for a read operation.
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 with zero waste. The first sentence states the purpose, and the second adds key behavioral detail (sorting). It's front-loaded and appropriately sized for a simple tool.
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 read-only tool with no annotations, 100% schema coverage, and no output schema, the description is minimally adequate. It covers purpose and sorting behavior but lacks details on return format (e.g., fields in speeches), error cases, or integration with sibling tools, leaving room for improvement.
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 fully documents both parameters (limit and since_date). The description doesn't add any parameter-specific details beyond what's in the schema, such as explaining how 'latest' interacts with since_date. Baseline 3 is appropriate when the schema does the heavy lifting.
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: 'Get the latest Federal Reserve speeches' specifies the verb (get) and resource (speeches). It distinguishes from siblings by focusing on 'latest' (most recent) rather than filtering by speaker, type, or search terms, though it doesn't explicitly name alternatives.
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 usage context through 'latest' and sorting by publication date, suggesting this tool is for retrieving recent speeches. However, it doesn't explicitly state when to use this vs. siblings like get_speeches_by_speaker or search_speeches, nor does it mention exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_speechA
Get a specific Federal Reserve speech by its document ID. Returns the full speech content and metadata.
| Name | Required | Description | Default |
|---|---|---|---|
| doc_id | Yes | The unique document identifier (e.g., 'fed-speech-abc123def456') |
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 that the tool returns 'full speech content and metadata', which adds useful context beyond the input schema. However, it lacks details on error handling, rate limits, or authentication needs, leaving 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 two concise sentences with zero waste: the first states the purpose, and the second specifies the return value. It is front-loaded and appropriately sized for a simple tool.
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 low complexity (1 parameter, no output schema, no annotations), the description is mostly complete. It covers purpose and return value, but lacks error handling or behavioral details, which would be beneficial for full 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?
Schema description coverage is 100%, so the schema already documents the doc_id parameter fully. The description adds no additional parameter details beyond what the schema provides, such as format examples or constraints, meeting the baseline for high schema coverage.
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 specific action ('Get') and resource ('a specific Federal Reserve speech by its document ID'), distinguishing it from siblings like get_latest_speeches or get_speeches_by_speaker. It specifies retrieving a single speech via ID rather than lists or filtered searches.
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 usage when you have a specific document ID, contrasting with siblings that handle bulk retrieval or filtering. However, it does not explicitly state when not to use this tool or name alternatives, leaving some ambiguity about overlapping use cases.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_speeches_by_speakerC
Get Federal Reserve speeches by a specific speaker. Filter by name, role, and date range.
| Name | Required | Description | Default |
|---|---|---|---|
| name | No | Speaker name (partial match, e.g., 'Powell' or 'Jerome Powell') | |
| role | No | Speaker role filter | |
| start_date | No | Start date filter (ISO 8601 format) | |
| end_date | No | End date filter (ISO 8601 format) |
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 mentions filtering by name, role, and date range but doesn't cover critical aspects like whether this is a read-only operation, potential rate limits, authentication needs, or what the output format looks like (e.g., list of speeches with details). This is a significant gap for a tool with multiple parameters and no output 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?
The description is a single, efficient sentence that front-loads the core purpose and lists key filters without unnecessary words. Every part earns its place, making it highly concise and 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?
Given the tool's complexity (4 parameters, no annotations, no output schema), the description is incomplete. It doesn't explain behavioral traits like safety or performance, and without an output schema, it fails to describe what the tool returns (e.g., speech titles, dates, content). This leaves gaps for an agent to use it effectively.
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 description coverage is 100%, so the input schema already documents all parameters thoroughly (e.g., 'name' as partial match, 'role' with enum values, date formats). The description adds minimal value by listing the filter types but doesn't provide additional semantics beyond what's in the schema, meeting the baseline for high coverage.
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 verb 'Get' and resource 'Federal Reserve speeches' with the specific constraint 'by a specific speaker', making the purpose evident. However, it doesn't explicitly differentiate from sibling tools like 'get_speeches_by_type' or 'search_speeches', which might offer overlapping functionality, so it doesn't reach the highest score.
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 no guidance on when to use this tool versus alternatives like 'get_speeches_by_type' or 'search_speeches'. It lists filtering capabilities but doesn't specify scenarios or exclusions, leaving the agent to infer usage from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_speeches_by_typeC
Get Federal Reserve speeches by document type (speech, testimony, or prepared_remarks).
| Name | Required | Description | Default |
|---|---|---|---|
| doc_type | Yes | Document type to filter by | |
| start_date | No | Start date filter (ISO 8601 format) | |
| end_date | No | End date filter (ISO 8601 format) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but lacks behavioral details. It doesn't disclose whether this is a read-only operation, how results are returned (e.g., pagination, format), rate limits, or error handling. The description is minimal and adds little beyond the basic function.
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, efficient sentence with zero wasteāit directly states the tool's purpose without unnecessary words. It's appropriately sized for a simple filtering tool and front-loaded with the key information.
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 annotations and no output schema, the description is incomplete for a tool with three parameters. It doesn't explain return values, error cases, or behavioral constraints, leaving significant gaps for the agent to operate effectively in a real-world 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?
Schema description coverage is 100%, so the schema fully documents all three parameters. The description mentions 'by document type' which aligns with the 'doc_type' parameter but doesn't add meaning beyond what the schema provides (e.g., explaining the enum values or date formats). Baseline 3 is appropriate as the schema does the heavy lifting.
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 ('Get') and resource ('Federal Reserve speeches') with specific filtering criteria ('by document type'). It distinguishes from siblings like 'get_latest_speeches' (no type filter) and 'get_speeches_by_speaker' (different filter), but doesn't explicitly contrast them, keeping it at 4 rather than 5.
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 no guidance on when to use this tool versus alternatives like 'search_speeches' or 'get_speeches_by_speaker'. It mentions the filter criteria but doesn't specify use cases or exclusions, leaving the agent to infer usage from the name alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_speech_statsB
Get statistics about stored Federal Reserve speeches.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden for behavioral disclosure. It states what the tool does but doesn't describe what statistics are returned, whether there are rate limits, authentication requirements, or what format the statistics come in. For a statistics tool with zero annotation coverage, this is inadequate.
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, efficient sentence that states exactly what the tool does with zero wasted words. It's appropriately sized for a simple tool and front-loads the essential information.
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 statistics retrieval tool with no annotations and no output schema, the description is insufficient. It doesn't explain what statistics are returned (counts, averages, distributions?), the format of the response, or any limitations. The agent would be left guessing about the tool's behavior and output.
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 0 parameters with 100% schema description coverage, so the schema already fully documents the parameter situation. The description appropriately doesn't mention parameters since none exist, earning a baseline 4 for not creating confusion about non-existent 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 the action ('Get statistics') and resource ('stored Federal Reserve speeches'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'get_speech' or 'get_latest_speeches' which retrieve speech content rather than statistics.
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?
No guidance is provided about when to use this tool versus alternatives like 'search_speeches' or 'get_speeches_by_speaker'. The description implies this returns aggregated statistics rather than individual speeches, but doesn't explicitly state this distinction or provide usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
refresh_speechesC
Fetch new speeches from the Federal Reserve website. This will check RSS feeds and optionally index pages for new content.
| Name | Required | Description | Default |
|---|---|---|---|
| include_index | No | Whether to also scan index pages (slower but more thorough) | |
| years | No | Years to scan for index pages (only used if include_index is true) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden but lacks critical behavioral details. It mentions that scanning index pages is 'slower but more thorough', which is useful, but doesn't disclose potential side effects (e.g., network calls, rate limits), authentication needs, or what 'fetch new' entails (e.g., updates a database). This leaves significant gaps for a tool that interacts with external sources.
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 highly concise with two sentences that directly address the tool's function and optional behavior. Every word contributes meaning without redundancy, making it easy to parse quickly.
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 annotations and no output schema, the description is incomplete for a tool that fetches from external sources. It doesn't explain what 'fetch new' means operationally (e.g., stores data, returns results), potential errors, or how results are handled, leaving the agent with insufficient context for reliable 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 description coverage is 100%, so the schema fully documents both parameters. The description adds minimal value by mentioning 'RSS feeds and optionally index pages', which loosely relates to parameters but doesn't provide additional syntax or format details beyond what the schema already specifies.
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 ('Fetch new speeches') and resource ('from the Federal Reserve website'), specifying it checks RSS feeds and optionally index pages. It distinguishes from siblings like 'get_latest_speeches' by focusing on fetching new content rather than retrieving existing data, though it could be more explicit about this distinction.
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 no guidance on when to use this tool versus alternatives like 'get_latest_speeches' or 'search_speeches'. It mentions optional index page scanning but doesn't explain scenarios where this is preferable, leaving usage context unclear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_speechesB
Search Federal Reserve speeches by keyword. Searches in title and content.
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query (keywords to search for) | |
| limit | No | Maximum number of results (default: 10) |
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 of behavioral disclosure. It mentions the search scope ('title and content') but lacks details on permissions, rate limits, pagination, error handling, or response format. For a search tool with zero annotation coverage, this is a significant gap in transparency about how the tool behaves beyond basic functionality.
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 highly concise and front-loaded with two sentences that directly state the tool's purpose and search scope. Every sentence earns its place without redundancy, making it efficient and easy for an agent to parse quickly.
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 lack of annotations and output schema, the description is incomplete for a search tool. It doesn't explain return values, result ordering, or potential limitations (e.g., partial matches, case sensitivity). With 2 parameters and no structured output guidance, more context is needed for the agent to use this tool effectively.
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%, with clear descriptions for both parameters ('query' and 'limit'). The description adds minimal value beyond the schema, only implying that the query searches 'title and content,' which doesn't provide additional syntax or format details. Baseline 3 is appropriate as the schema does the heavy lifting.
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: 'Search Federal Reserve speeches by keyword. Searches in title and content.' It specifies the verb ('Search'), resource ('Federal Reserve speeches'), and scope ('by keyword' with search fields). However, it doesn't explicitly differentiate from siblings like 'get_latest_speeches' or 'get_speeches_by_speaker' beyond the search functionality.
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 usage context through 'Search by keyword' and 'Searches in title and content,' suggesting this tool is for keyword-based searches rather than retrieval by other attributes. However, it doesn't explicitly state when to use this vs. alternatives like 'get_speeches_by_speaker' or provide any exclusions or prerequisites, leaving some ambiguity for the agent.
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 with no overlap. The tools cover different access patterns (latest, specific, by speaker, by type, statistics, refresh, search) without ambiguity, making it easy for an agent to select the right tool for any query about Federal Reserve speeches.
All tools follow a consistent verb_noun pattern with clear, descriptive names. The naming scheme is uniform throughout (e.g., get_latest_speeches, get_speech, get_speeches_by_speaker), making it predictable and easy to understand the tool's function from its name alone.
With 7 tools, the server is well-scoped for its domain of accessing Federal Reserve speeches. Each tool serves a specific and necessary function, covering retrieval, filtering, statistics, updating, and search operations without being overly sparse or bloated.
The tool set provides complete coverage for the domain, including CRUD-like operations (get, refresh), filtering by various attributes (speaker, type, date), search functionality, and statistical insights. There are no obvious gaps that would hinder an agent from performing typical speech-related tasks.
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
Investment research superagent: podcasts, SEC filings, and no-code research pipelines.
Search speech in podcasts, government meetings, and your own audio: speakers, entities, timestamps.
Read, search and track your RSS feeds: semantic search, story clustering, watches, OPML import.
RSS, Atom and JSON feeds for agents: find a site's feed, read items as JSON, keyless news search.
Related MCP Servers
- FlicenseAqualityDmaintenanceEnables searching and retrieving economic data from the Federal Reserve Economic Data (FRED) API, including time series, categories, releases, and popular indicators.71
- AlicenseNot gradedqualityBmaintenanceFetches and searches structured JSON feeds from 7 tech sources including GeekNews, Hacker News, and arXiv.17MIT
- FlicenseNot gradedqualityCmaintenanceRead-only MCP server for monitoring public RSS and Atom feeds from competitor and industry websites, enabling competitive intelligence workflows through feed fetching, searching, and thematic summarization.
- AlicenseAqualityDmaintenanceEnables users to search, retrieve, and explore economic data series from the Federal Reserve Economic Data (FRED) API using natural language.11MIT
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/zsun4work/fed-speech-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server