birdnet-go-mcp
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., "@birdnet-go-mcpWhat bird species were detected in the last 24 hours?"
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.
birdnet-go-mcp
Highlights
Native BirdNET-Go Support: Interfaces directly with BirdNET-Go's v2 REST API over LAN or localhost. No raw database locking or unmaintained Python dependencies.
Instant
npxRun: Launch immediately withnpx -y birdnet-go-mcpβ zero Go toolchain required.Zero-Dependency Static Binary: Single Go binary (
CGO_ENABLED=0) compiled for Linux, macOS, and Windows.Dual-Mode (CLI + MCP): Human-friendly CLI for quick terminal health checks (
birdnet-mcp status), plus full stdio & SSE MCP server for AI agents.Context-Protected (8KB Envelope): Hard-capped output preventing multi-hundred detection queries from overflowing model context windows.
Read-Only & Parallel-Safe: Omits all mutating/destructive endpoints. Annotates all tools with
readOnlyHintandidempotentHintfor fast parallel agent calls.Audio & Clip Access: Resolves LAN Caddy/Nginx
.wavclip URLs, with built-in base64 audio streaming for multimodal models.
Related MCP server: eBird MCP Server
Quick Start
1. Instant Run via NPX (Recommended for Claude Desktop & Node users)
No Go installation needed. Downloads the native binary for your platform automatically:
# Check station health in your terminal
npx -y birdnet-go-mcp status
# Or set target host
BIRDNET_BASE_URL="http://192.0.2.10:8080" npx -y birdnet-go-mcp recent2. Install via Go
go install github.com/zax0rz/birdnet-go-mcp/cmd/birdnet-mcp@latest3. Pre-Compiled Binaries
Download the latest static binary for your architecture from GitHub Releases:
darwin-arm64(Apple Silicon M1/M2/M3/M4)darwin-amd64(Intel Mac)linux-amd64(x86_64 servers, Proxmox LXC, Docker)linux-arm64(Raspberry Pi 4 / 5)linux-armv7(Raspberry Pi 2 / 3 / Zero 2 W)windows-amd64
Client & Harness Setup
Claude Desktop & Cursor
Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS), %APPDATA%\Claude\claude_desktop_config.json (Windows), or add under Cursor Settings β Features β MCP:
Option A: Using npx (Easiest)
{
"mcpServers": {
"birdnet": {
"command": "npx",
"args": ["-y", "birdnet-go-mcp", "serve"],
"env": {
"BIRDNET_BASE_URL": "http://192.0.2.10:8080",
"CLIPS_BASE_URL": "http://192.0.2.10:8091"
}
}
}
}Option B: Using Native Binary
{
"mcpServers": {
"birdnet": {
"command": "/usr/local/bin/birdnet-mcp",
"args": ["serve"],
"env": {
"BIRDNET_BASE_URL": "http://192.0.2.10:8080",
"CLIPS_BASE_URL": "http://192.0.2.10:8091"
}
}
}
}Claude Code
Add directly via CLI:
claude mcp add birdnet -- npx -y birdnet-go-mcp serveGoogle Antigravity
In your Antigravity MCP configuration (~/.gemini/antigravity/mcp/ or project settings):
{
"mcpServers": {
"birdnet": {
"command": "birdnet-mcp",
"args": ["serve"],
"env": {
"BIRDNET_BASE_URL": "http://192.0.2.10:8080",
"CLIPS_BASE_URL": "http://192.0.2.10:8091"
}
}
}
}OpenClaw
In ~/.openclaw/openclaw.json:
{
"mcp": {
"servers": {
"birdnet": {
"command": "/Users/zach/.openclaw/mcp-servers/birdnet-go-mcp/bin/birdnet-mcp",
"args": [],
"env": {
"BIRDNET_BASE_URL": "http://192.0.2.10:8080",
"CLIPS_BASE_URL": "http://192.0.2.10:8091"
},
"toolFilter": {
"include": ["*"]
}
}
}
}
}In your agent's tools.allow list:
"tools": {
"allow": [
"birdnet__get_recent_detections",
"birdnet__search_detections",
"birdnet__get_detection_detail",
"birdnet__get_today_summary",
"birdnet__get_new_arrivals",
"birdnet__get_station_health",
"birdnet__get_audio_clip",
"birdnet__get_audio_clip_base64"
]
}Remote / Headless Agents (SSE HTTP Mode)
If your agent runs on another machine or in the cloud without access to local stdio:
# Start background SSE server on port 8092
birdnet-mcp serve --sse --port 8092Point your agent to:
http://<your-server-ip>:8092/sse
Interactive CLI Commands
birdnet-mcp is a full CLI tool for humans as well as an MCP server for agents.
Check Station & RTSP Mic Health
$ birdnet-mcp status
π Connecting to BirdNET-Go at http://192.0.2.10:8080...
=== AUDIO STREAMS ===
NAME TYPE HEALTH STATE THROUGHPUT LAST RECEIVED
birdz0rz-pi rtsp π’ HEALTHY running 74.8 KB/s 2026-09-04T20:38:53-04:00
=== DETECTOR HOST ===
Host: birdz0rz (Debian Linux, x86_64)
CPU: AMD Ryzen 5 PRO 2400G (2 cores)
Uptime: 15d 3h 6m (Host) | 6d 4h 47m (BirdNET-Go)
Kernel: 7.0.14-12-pve
Environment: LXCView Recent Sightings
$ birdnet-mcp recent --limit 5 --min-conf 0.80
ID TIME SPECIES COMMON NAME CONF NEW? CLIP URL
#129 2026-09-04 19:59:35 easblu Eastern Bluebird 84% - http://192.0.2.10:8091/2026/09/sialia_sialis_84p_20260904T195937Z.wav
#128 2026-09-04 19:58:17 easblu Eastern Bluebird 95% - http://192.0.2.10:8091/2026/09/sialia_sialis_95p_20260904T195819Z.wav
#127 2026-09-04 19:05:23 blujay Blue Jay 84% - http://192.0.2.10:8091/2026/09/cyanocitta_cristata_84p_20260904T190525Z.wav
#126 2026-09-04 18:46:16 carwre Carolina Wren 96% - http://192.0.2.10:8091/2026/09/thryothorus_ludovicianus_96p_20260904T184618Z.wav
#124 2026-09-04 18:35:34 houfin House Finch 90% - http://192.0.2.10:8091/2026/09/haemorhous_mexicanus_90p_20260904T183536Z.wavDownload Audio Recording
$ birdnet-mcp clip sialia_sialis_95p_20260904T195819Z.wav --download --out bluebird.wav
β
Saved 1440044 bytes to bluebird.wavMCP Tool Reference
Tool | Parameters | Description |
|
| Fetches the most recent bird acoustic detections with confidence scores, timestamps, and audio clip URLs. |
|
| Historical search through detection records stored in SQLite. |
|
| Inspects a single detection: weather conditions at detection time, confidence breakdown, and audio clip info. |
| (none) | Aggregate summary of today's observatory run: total count, species diversity, and top visitors. |
| (none) | Identifies species heard for the first time ever or new this season/year (vital for tracking migration). |
| (none) | Real-time diagnostic telemetry: RTSP mic stream state, ingest bit rate, dropped packets, and host uptime. |
|
| Resolves the accessible LAN URL on Caddy/Nginx (:8091) for Discord/web embedding. |
|
| Downloads and base64-encodes the raw |
MCP Resources
birdnet://station/healthβ Live JSON snapshot of the Pi mic stream and BirdNET-Go engine.birdnet://detections/recentβ The 10 most recent detections.birdnet://species/summaryβ Aggregated species occurrence summary.
MCP Prompts
daily_backyard_briefβ Morning dispatch workflow template for resident bird agents.investigate_detectionβ Deep-dive template for evaluating anomalous sightings against eBird.
Configuration Reference
Environment Variable | CLI Flag | Default | Description |
|
|
| BirdNET-Go v2 REST API base URL |
|
|
| Base URL for audio clips file server |
|
| (empty) | Optional HTTP Basic Auth username |
|
| (empty) | Optional HTTP Basic Auth password |
|
| (empty) | Optional Bearer authorization token |
| (none) |
| HTTP client timeout in seconds |
Field-Tested in Production: The Origin Story & Hardening
birdnet-go-mcp wasn't built in a theoretical vacuum β it was forged and verified against a live backyard bioacoustic observatory:
Mic Station: Raspberry Pi Zero 2 W mounted outdoors with a weather-sealed electret microphone streaming 48kHz mono audio via RTSP (
mediamtx) at ~75 KB/s over Wi-Fi.Detector Host: BirdNET-Go running inside a Debian 12 Proxmox LXC container (
amd64, AMD Ryzen 5 PRO), analyzing audio chunks with the Cornell Lab of Ornithology neural network.Clip Web Server: Caddy reverse proxy serving
/var/lib/birdnet-go/clips/over HTTP on port 8091.Agent Mesh: OpenClaw on an Apple Silicon Mac Mini running autonomous resident agents:
Blenda (Infra agent, GLM-5.3): Monitors server health, manages gateway restarts, and oversees tool permissions.
Leopold (Resident Naturalist, Gemini 3.8 Flash): Composes daily backyard wildlife briefings, flags unusual species (Eastern Bluebirds, Carolina Wrens, Pileated Woodpeckers), and inspects audio spectrograms.
Real-World Lessons & "Incident Zero"
The Caddy Directory Permission Trap (Incident Zero): BirdNET-Go creates monthly clip directories (
/clips/YYYY/MM/) with750permissions (drwxr-x---). External web servers (Caddy, Nginx) running as their own system user will hit HTTP 403 Forbidden when serving audio clips to agents or Discord webhooks. Fix: Set permissions to755on existing month folders and add your web server user to thebirdnetgroup:sudo chmod -R 755 /var/lib/birdnet-go/clips sudo usermod -aG birdnet caddyApple Silicon AMFI & Cross-Compilation: When cross-compiling Go binaries from Linux for macOS (
GOOS=darwin GOARCH=arm64) with stripped debug symbols (-ldflags="-s -w"), macOS Apple Mobile File Integrity (AMFI) will immediately terminate the process withSIGKILL(exit code 137). All Darwin ARM64 releases are properly ad-hoc codesigned (codesign -s - --force).Context Window Token Budget Guard: Feeding raw base64 WAV recordings into multimodal LLMs is magical for verifying difficult bird calls, but a single 15-second WAV consumes ~1.9MB (approx. 500,000 tokens). That can consume 50% of a 1M-token context window in one tool invocation.
birdnet-go-mcpstrictly caps all structured JSON tool responses at an 8KB envelope cap, while keepingget_audio_clip_base64explicitly exempt so models can call it intentionally without risk of accidental context blowup in daily briefing routines.
Contributing & Development
# Clone
git clone https://github.com/zax0rz/birdnet-go-mcp.git
cd birdnet-go-mcp
# Run unit tests
make test
# Build for local OS
make build
# Cross-compile for Darwin ARM64 (Apple Silicon)
make build-macCredits & License
Built with
mark3labs/mcp-go.Designed for
tphakala/birdnet-go.Bird identification neural network developed by the Cornell Lab of Ornithology and Chemnitz University of Technology.
Licensed under the MIT License.
Available Tools
8 toolsget_audio_clipARead-onlyIdempotent
Resolve a detection's audio clip (.wav) into a full HTTP URL on the clips file server, for sharing or embedding in messages and web pages. The URL is only reachable from the same network as the clips server. Use get_audio_clip_base64 instead when the audio data must be returned inline to the model.
| Name | Required | Description | Default |
|---|---|---|---|
| clip_name | Yes | Clip file name exactly as returned in a detection record, e.g. 'sialia_sialis_96p_20260829T192351Z.wav' | |
| detection_date | No | Detection date in YYYY-MM-DD format; used as a fallback to locate the clip's folder when the filename embeds no parseable date |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context beyond those annotations: the generated URL is only reachable from the same network as the clips server, and this tool returns a URL rather than inline data. This is useful and does not contradict the annotations.
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 with no filler. It front-loads the core action and output, then states the network caveat, then gives the routing instruction to the sibling tool. Every sentence earns its place.
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 URL-resolution tool with rich annotations and full schema coverage, the description is complete. It explains what is returned, flags a critical network limitation, and points to the appropriate alternative when inline data is needed. No important guidance is missing for an agent to select and use it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the input schema already documents both clip_name and detection_date in sufficient detail. The description does not add substantial semantic information about the parameters beyond what the schema provides, so the baseline score of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Resolve'), a specific resource ('a detection's audio clip (.wav)'), and the output form ('full HTTP URL'), with the purpose of sharing or embedding. It also distinguishes itself from the sibling get_audio_clip_base64, so an agent can clearly tell what this tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly names the alternative tool get_audio_clip_base64 and gives the exact condition for choosing it: when the audio data must be returned inline to the model. It also conveys a constraint on URL reachability, which helps an agent decide whether this tool is appropriate for a given context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_audio_clip_base64ARead-onlyIdempotent
Download a detection's audio clip (.wav) and return it base64-encoded, for multimodal models that accept audio input directly. WARNING: a 15-second clip is roughly 350,000-500,000 tokens. Call sparingly for single-clip verification only β never inside high-frequency or scheduled workflows. Use get_audio_clip for a lightweight shareable URL instead.
| Name | Required | Description | Default |
|---|---|---|---|
| clip_name | Yes | Clip file name exactly as returned in a detection record, e.g. 'sialia_sialis_96p_20260829T192351Z.wav' | |
| detection_date | No | Detection date in YYYY-MM-DD format; used as a fallback to locate the clip's folder when the filename embeds no parseable date |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Goes well beyond annotations by disclosing the severe token cost (350k-500k per 15s clip) and warning about appropriate invocation frequency. This is crucial behavioral context for an AI agent deciding whether to call the tool, and it complements the readOnlyHint and idempotentHint without contradicting them.
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?
Every sentence serves a distinct purpose: what the tool does, why it exists, a critical warning, and a pointer to the lighter alternative. No filler, and the most important operational caution (token size) 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?
For a simple two-parameter download tool with no output schema, the description covers the essential behavioral aspects: output format, cost implications, usage frequency constraints, and the alternative. Everything an agent needs to decide whether to invoke this tool and how to do so safely is present.
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% and both parameters are adequately documented in the schema itself. The tool description adds no additional parameter-level detail, which is acceptable given the schema already explains clip_name and detection_date thoroughly. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('Download'), a specific resource (detection's .wav audio clip), and a specific output format (base64-encoded). This makes the tool's purpose unambiguous and clearly distinguishes it from the sibling get_audio_clip by explaining what makes this version different (direct audio input for multimodal models).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit usage guidance: use for single-clip verification only, never in high-frequency or scheduled workflows, and names the alternative get_audio_clip for when a lightweight shareable URL is sufficient. These are clear when-to-use and when-not-to-use instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_detection_detailARead-onlyIdempotent
Get comprehensive details for a single detection by its numeric ID (obtained from get_recent_detections or search_detections): weather conditions at detection time, confidence score, and audio clip URL. Use after an interesting detection ID has been identified.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | Numeric detection ID, as returned by get_recent_detections or search_detections |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover read-only, idempotent, non-destructive, and open-world behavior, so the bar for additional disclosure is lower. The description adds useful context about the return contents (weather, confidence, audio URL). It does not mention potential edge cases such as missing detections or whether the audio URL requires further authentication, but this is acceptable given the 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?
The description is two sentences with no filler. The first sentence front-loads the core action, resource, and ID source; the second sentence gives a clear usage trigger. Every piece of information earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter lookup tool with no output schema, the description provides the essential information: what the tool does, what it returns, where the ID comes from, and when to use it. It could be slightly more explicit about the response shape or error behavior, but the description is sufficient for an agent to invoke the tool 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 description coverage is 100% and the single 'id' parameter is well-described in the schema as a numeric detection ID returned by get_recent_detections or search_detections. The description reinforces this same information but does not add significant new semantic detail beyond the 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 states a specific verb ('Get'), a specific resource ('comprehensive details for a single detection'), and the key identifier (numeric ID). It also lists the specific content returned (weather conditions, confidence score, audio clip URL), making the tool's purpose both concrete and distinguishable from sibling tools focused on audio clips, summaries, and list 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 clearly indicates when to use the tool: 'Use after an interesting detection ID has been identified.' It also specifies how to obtain the ID, from get_recent_detections or search_detections. It does not explicitly name alternatives or exclusion cases, but the contextual guidance is strong enough for an agent to select this tool appropriately.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_new_arrivalsARead-onlyIdempotent
List species detected for the first time ever, or newly arrived this season/year. Use this to spot migration events, rare visitors, or new residents.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint false, clearly establishing safe read-only behavior. The description adds no further behavioral details, but with annotations present, the bar is lower for additional context. The tool has no side effects, so the annotation coverage is sufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, direct, and free of extraneous detail. It states the function and the intended use without redundancy, achieving high clarity in minimal length.
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 provides a complete definition and clear use cases, allowing an agent to decide when to call this tool. Since it is a read-only list with no parameters and the sibling tools are differentiated, no further context is needed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so there is nothing to explain. The schema coverage is 100% (empty object), and the description does not need to add parameter meaning. This dimension is trivially satisfied.
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 lists species detected for the first time ever or newly arrived this season/year, providing a specific verb (list) and resource (species). It distinguishes itself from siblings like get_recent_detections and get_today_summary by focusing on new arrivals rather than all recent activity.
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 gives explicit use cases: 'Use this to spot migration events, rare visitors, or new residents.' This tells the agent when to invoke the tool, though it does not explicitly contrast with sibling tools. However, the purpose clarity already differentiates it from alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_recent_detectionsARead-onlyIdempotent
Retrieve the most recent bird acoustic detections from the BirdNET-Go observatory. Returns species names, confidence scores, timestamps, and audio clip URLs. Use this as the primary tool for 'what birds were heard recently?' questions; use search_detections for historical lookups or get_today_summary for aggregates. All output is capped at 8KB to protect the agent context window.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Number of detections to return (default: 10, max: 25) | |
| species_code | No | Optional 6-letter species code filter (e.g. 'easblu', 'blujay', 'rebwoo') | |
| min_confidence | No | Minimum confidence score between 0.0 and 1.0 (default: 0.70) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, so the safety profile is clear. The description adds useful behavioral context beyond the annotations by noting that output is capped at 8KB to protect the agent context window and by listing typical return fields.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured: purpose first, then return contents, then explicit sibling-tool routing, then the output cap note. Every sentence adds value and there is no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the moderate complexity (three optional parameters, no output schema), the description is largely complete: it states the resource, the return fields, the primary use case, and a system constraint (8KB cap). It does not explicitly mention error behavior or empty results, but the 'most recent' wording and output cap cover the main operational context an agent needs.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% and every parameter has its own description with defaults and bounds (limit, species_code, min_confidence). The description does not need to add much, and it does not; it provides no extra semantic information beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific action ('Retrieve the most recent bird acoustic detections') and a specific resource ('BirdNET-Go observatory'), and it lists the returned data fields. It also differentiates itself from sibling tools by naming search_detections and get_today_summary for other use cases.
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 gives explicit when-to-use guidance: 'Use this as the primary tool for "what birds were heard recently?" questions' and directs users to search_detections for historical lookups and get_today_summary for aggregates. This removes ambiguity about tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_station_healthARead-onlyIdempotent
Get real-time health telemetry for the monitoring station: audio stream state and ingest throughput, packet loss, and host uptime/CPU. Use this to diagnose a silent station or missing detections before other tools.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds the 'real-time' nature of the data and the concrete telemetry fields, which gives the agent useful expectations beyond the annotations. No contradictions or hidden side effects are indicated.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no filler: the first front-loads what the tool returns, and the second clarifies when to use it. Every sentence earns its place and the structure is easy to scan.
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?
With no output schema, the description appropriately lists the returned telemetry content and explains a concrete use case. The absence of an explicit response format or caveats is a minor gap, but zero required parameters and strong annotations keep this sufficiently 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?
The tool takes zero parameters and schema description coverage is 100%, so there is no parameter-documentation burden. The description is not required to explain inputs and adds no irrelevant parameter detail; the baseline of 4 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Get') with a clear resource ('real-time health telemetry for the monitoring station') and enumerates the included metrics. None of the sibling tool names overlap with health-telemetry scope, so it is immediately distinguishable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly states the diagnostic scenario ('silent station or missing detections') and gives ordering guidance ('before other tools'). It does not name alternatives or state when not to use it, but the intended context is clear enough for an agent to select it appropriately.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_today_summaryARead-onlyIdempotent
Get an aggregate summary of today's observatory activity: per-species detection counts plus first and last heard times. Use for daily briefings or 'what happened today' questions.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnly, idempotent, and non-destructive behavior, so no contradiction exists. The description adds transparency about the content returned (per-species counts and time ranges), which goes beyond the annotations and helps the agent anticipate output. This additional context earns a solid score.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, using two short sentences to convey the tool's purpose and use cases without unnecessary fluff. It is well-structured, front-loading the core function and then providing context. Every word adds value, making it highly efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (no parameters) and the richness of the schema annotations, the description fully covers what the agent needs to know. It specifies the output content (per-species counts, first/last heard times) and the intended scenarios ('daily briefings', 'what happened today'), making it complete. The absence of an output schema is not an issue here as the description fills that gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the baseline score of 4 applies. The description correctly omits parameter details since none exist, and the schema provides full coverage at 100%. No additional semantic explanation is needed, but the score reflects the baseline for parameterless tools.
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 with a specific verb ('Get'), resource ('aggregate summary of today's observatory activity'), and scope (per-species detection counts, first/last heard times). It distinguishes itself from sibling tools by its unique focus on daily summary aggregates, and the mention of use cases further clarifies its intent.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly provides usage guidance by stating 'Use for daily briefings or 'what happened today' questions,' making it clear when to deploy this tool. It also implies when not to use it (e.g., for detailed per-detection queries, which are covered by other siblings), though it doesn't name alternatives directly, but the explicit use cases are sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_detectionsARead-onlyIdempotent
Search historical detection records by date, species name/code, and minimum confidence. Use this to answer questions about a specific day, date range, or species across history. For the latest activity use get_recent_detections instead. Dates must be YYYY-MM-DD.
| Name | Required | Description | Default |
|---|---|---|---|
| date | No | Filter by date in YYYY-MM-DD format (e.g. '2026-08-29') | |
| limit | No | Max results to return (default: 10, max: 25) | |
| species | No | Species common name or 6-letter code (e.g. 'Eastern Bluebird' or 'easblu') | |
| min_confidence | No | Minimum confidence score between 0.0 and 1.0 (default: 0.70) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds useful context by clarifying that this searches historical records rather than live activity and by requiring YYYY-MM-DD dates. It does not describe result ordering or pagination, but the schema's limit parameter and the safety annotations keep this a minor omission.
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 short sentences with no fluff: the action and resource come first, usage context and the sibling alternative follow, and the format constraint is stated plainly. Every sentence earns its place.
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, idempotent search tool with 0 required parameters and no output schema, this description covers purpose, when to use it, the key alternative, and the required date format. It stops short of describing the return value structure or ordering, but that is a modest gap given the rich annotations and fully documented params. The phrase 'date range' is slightly underspecified since the schema only exposes a single date parameter.
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 schema already documents each parameter's format and defaults. The description reinforces the same filters ('date, species name/code, and minimum confidence') but adds little semantic value beyond the schema, aside from emphasizing the date format.
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 historical detection records by date, species name/code, and minimum confidence,' naming a specific verb, resource, and the exact filter dimensions. It also explicitly contrasts with get_recent_detections, so the agent can distinguish this history search from the latest-activity sibling without inspecting schemas.
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 states the exact conditions for use ('specific day, date range, or species across history') and names the alternative for the excluded case ('For the latest activity use get_recent_detections instead'). This is an explicit when/alternative routing with nothing left to inference.
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.
8 tool updates
v1.0.0- First observed
get_audio_clip - First observed
get_audio_clip_base64 - First observed
get_detection_detail - First observed
get_new_arrivals - First observed
get_recent_detections - First observed
get_station_health - First observed
get_today_summary - First observed
search_detections
TDQS
Scored across 8 tools
Each tool serves a distinct purpose: audio retrieval (URL vs base64), detection details, recent/search/summary views, health status, and new arrivals. No overlapping functionality or ambiguous boundaries.
All tools follow a consistent get_ prefix for retrieval operations, with search_ appropriately used for the query tool. The base64 suffix clearly differentiates the inline-data variant from the URL variant.
With 8 tools, the set is well-scoped for a bird-observation monitoring serviceβcovering the essential read and search operations without redundancy or bloat.
The surface covers all likely read-oriented needs for this domain: recent detections, historical search, summaries, per-detection details, audio retrieval (both URL and base64), health status, and new arrivals. No significant gaps are evident.
Maintenance
Related MCP Connectors
Gateway between LLM agents and world data through eight tools and a bundled endpoint catalog.
YouTube transcripts, search, channels, playlists and bulk transcript jobs for AI agents. 14 tools.
Provide detailed PokΓ©mon data and information through a standardized MCP interface. Enable LLMs anβ¦
YouTube transcripts, search, channel/playlist listings and upload tracking for AI agents.
Related MCP Servers
- AlicenseAqualityDmaintenanceCross-reference your BirdNET-Pi data with eBird observations using natural language34 npm1MIT
- AlicenseNot gradedqualityDmaintenanceIntegrates the eBird API with Claude to query bird observation data, including recent sightings, rare bird reports, contributor statistics, hotspot locations, and taxonomy information through natural language.5MIT
- AlicenseAqualityDmaintenanceAn AI-powered birding companion that connects Claude to eBird and Xeno-canto APIs, enabling personalized birding with life list tracking, route-based hotspot discovery, and recording enrichment.282MIT
- FlicenseAqualityAmaintenanceEnables AI assistants to interact with Frigate NVR security camera systems, supporting camera management, event detection, snapshots, recordings, and system stats via natural language.710-