Skip to main content
Glama
zsun4work
by zsun4work

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 sync

That'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 sync

Step 2: Fetch Speeches from Fed Website

uv run python scripts/test_local.py refresh --limit 5

You'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: 5

Step 3: Explore the Data

View latest speeches:

uv run python scripts/test_local.py latest --limit 3

Output:

šŸ“° 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-abc123

Search 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-abc123

View statistics:

uv run python scripts/test_local.py stats

Step 4: Run All Tests

uv run python scripts/test_local.py all

This runs a complete test suite: refresh → stats → latest → search → filter → get.

Available Test Commands

Command

Description

Example

refresh

Fetch new speeches

--limit 5, --include-index

latest

Show latest speeches

--limit 10, --since 2024-01-01

search

Search by keyword

--query "inflation"

speaker

Filter by speaker

--name "Powell", --role "Chair"

type

Filter by doc type

--doc-type testimony

get

Get full speech

--doc-id fed-speech-xxx

stats

Show statistics

(no options)

all

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 sync

Step 2: Locate Claude Desktop Config

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

  • Windows: %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-mcp with 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 sync

Step 2: Open Cursor Settings

  1. Open Cursor IDE

  2. Go to Settings (⌘+, on macOS, Ctrl+, on Windows)

  3. 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 sync

Step 2: Start the HTTP API Server

uv run fed-speech-http

The 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 8000

Copy the public URL (e.g., https://abc123.ngrok.io).

Step 4: Create a Custom GPT

  1. Go to ChatGPT

  2. Click your profile → My GPTs → Create a GPT

  3. 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.
  4. 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 result

Step 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-http

Step 2: Expose to Internet

ngrok http 8000

Step 3: Use with Google AI Studio

  1. Go to Google AI Studio

  2. Create a new prompt or chat

  3. 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

/speeches/latest

GET

Get latest speeches

/speeches/search

GET

Search by keyword

/speeches/{doc_id}

GET

Get specific speech

/speeches/by-speaker

GET

Filter by speaker

/speeches/by-type

GET

Filter by doc type

/speeches/refresh

POST

Fetch new speeches

/speeches/stats

GET

Get statistics

Query Parameters

  • limit - Max results (default: 10, max: 50)

  • since_date - ISO 8601 date filter

  • start_date / end_date - Date range

  • name - 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-http

Available 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 filter

  • end_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 filter

  • end_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 query

  • limit (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

FED_SPEECH_DATA_DIR

Data storage directory

./data

FED_SPEECH_HTTP_TIMEOUT

HTTP request timeout (seconds)

30

FED_SPEECH_MAX_RETRIES

Max retry attempts

3

FED_SPEECH_HTTP_PORT

HTTP API server port

8000

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_mcp

Running 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.md

License

MIT

Acknowledgments

Data sourced from the Federal Reserve Board.

Available Tools

7 tools
get_latest_speechesA

Get the latest Federal Reserve speeches. Returns speeches sorted by publication date, most recent first.

ParametersJSON Schema
NameRequiredDescriptionDefault
limitNoMaximum number of speeches to return (default: 10, max: 50)
since_dateNoOnly return speeches published on or after this date (ISO 8601 format, e.g., '2024-01-01')

TDQS

A3.5/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness3/5

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.

Parameters3/5

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.

Purpose4/5

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.

Usage Guidelines3/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
doc_idYesThe unique document identifier (e.g., 'fed-speech-abc123def456')

TDQS

A4/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters3/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
nameNoSpeaker name (partial match, e.g., 'Powell' or 'Jerome Powell')
roleNoSpeaker role filter
start_dateNoStart date filter (ISO 8601 format)
end_dateNoEnd date filter (ISO 8601 format)

TDQS

C2.9/5.0
Behavior2/5

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.

Conciseness5/5

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.

Completeness2/5

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.

Parameters3/5

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.

Purpose4/5

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.

Usage Guidelines2/5

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).

ParametersJSON Schema
NameRequiredDescriptionDefault
doc_typeYesDocument type to filter by
start_dateNoStart date filter (ISO 8601 format)
end_dateNoEnd date filter (ISO 8601 format)

TDQS

C2.9/5.0
Behavior2/5

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.

Conciseness5/5

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.

Completeness2/5

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.

Parameters3/5

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.

Purpose4/5

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.

Usage Guidelines2/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

B3.1/5.0
Behavior2/5

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.

Conciseness5/5

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.

Completeness2/5

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.

Parameters4/5

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.

Purpose4/5

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.

Usage Guidelines2/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
include_indexNoWhether to also scan index pages (slower but more thorough)
yearsNoYears to scan for index pages (only used if include_index is true)

TDQS

C2.9/5.0
Behavior2/5

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.

Conciseness5/5

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.

Completeness2/5

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.

Parameters3/5

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.

Purpose4/5

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.

Usage Guidelines2/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault
queryYesSearch query (keywords to search for)
limitNoMaximum number of results (default: 10)

TDQS

B3.2/5.0
Behavior2/5

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.

Conciseness5/5

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.

Completeness2/5

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.

Parameters3/5

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.

Purpose4/5

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.

Usage Guidelines3/5

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

A3.7/5.0
Disambiguation5/5

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.

Naming Consistency5/5

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.

Tool Count5/5

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.

Completeness5/5

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

ActivityInactive
ResponsivenessSyncing

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

Related MCP Servers

Latest Blog Posts

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