kids-radar-mcp

by kimtami

Overview Schema Related Servers Score Discussions

Python

Local

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.1.0
Disambiguation5/5
Each tool has a clearly distinct purpose: listing sources, fetching by ID, searching by coordinates, rendering a digest, getting status, and refreshing sources. No two tools overlap in function, making selection unambiguous.
Naming Consistency5/5
All tools follow a consistent verb_noun snake_case pattern (e.g., list_experience_sources, get_experience, render_nearby_digest). The verbs are descriptive and the nouns consistently name the target resource, making the toolset predictable.
Tool Count5/5
With 6 tools, the server covers its core workflows without bloat. Each tool earns its place, ranging from data ingestion and query to status reporting and digest rendering.
Completeness5/5
The toolset provides a complete set of operations for the radar use case: listing/refreshing sources, fetching a specific experience, searching nearby, rendering a digest, and checking system status. There are no dead ends or obvious missing operations for this domain.
Average 3.7/5 across 6 of 6 tools scored. Lowest: 3.1/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 2 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI is passing
This repository is licensed under MIT License.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds the specific behavioral guarantee 'never writes files or sends webhooks', which goes beyond the readOnlyHint and destructiveHint annotations by naming concrete side-effect-free operations. This provides extra context without contradicting annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that states the purpose and a key safety property. It is appropriately concise and every part earns its place, though it sacrifices detail for brevity.
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?
Despite having an output schema, the description is too sparse for a tool with 10 parameters and a non-trivial concept like 'nearby digest'. It lacks context on what a digest contains, how it relates to sibling search tools, or any usage prerequisites, leaving the agent under-informed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema covers about 60% of parameters with descriptions, but the tool description itself adds no parameter information. For a tool with 10 parameters, the description's silence on meaning, defaults, or interdependencies leaves a notable gap that the schema only partially fills.
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 uses a specific verb 'Render' and a clear resource 'local nearby digest', which conveys a distinct purpose from siblings like 'search_nearby_experiences'. However, 'digest' remains somewhat ambiguous and doesn't explicitly differentiate from the search tool, so it doesn't earn a 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 such as search_nearby_experiences or get_experience. It only states what the tool does, not the context or exclusion criteria, so it offers minimal usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare the tool as read-only, idempotent, and non-destructive. The description adds the behavioral detail that 'raw source payloads are never returned,' which is useful beyond annotations, but it does not disclose other behaviors like pagination, sorting, or filtering semantics.
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 extremely concise: two short sentences that state the core purpose and a key behavioral guarantee. Every word adds value, and it is front-loaded with the primary action and resource.
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?
With 11 parameters and a rich output schema, the description is far too sparse to guide an agent on how to set parameters like radius_km, free_only, or max_stale_hours effectively. It does not mention pagination, defaults, or any selection criteria, making it incomplete for correct invocation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is only 55%, and several parameters (free_only, include_closed, include_unknown_location) lack schema descriptions. The tool description adds no parameter-specific meaning beyond mentioning coordinates, leaving gaps that the schema alone does not fill.
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 tool's action ('Search'), resource ('local DB'), and method ('by coordinates'), making its purpose immediately understandable. It distinguishes from siblings like list_experience_sources (listing sources) and get_experience (fetching a specific experience) by emphasizing geospatial search.
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 explicit guidance is provided on when to use this tool versus alternatives such as render_nearby_digest or get_radar_status. Usage context is only implied through the name and coordinate-based description, with no stated exclusions or comparison to sibling tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already disclose the safety profile (not read-only, open-world, non-idempotent, not destructive). The description adds a critical latency warning ('may take several minutes') and the constraint that sources must be 'allowlisted', which is useful beyond the annotations. However, it does not disclose side effects like data mutations or rate-limit behavior.
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?
Two tightly written sentences, front-loaded with the verb and resource. The latency note is essential and efficiently conveyed without any wasted words.
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 complex long-running crawler, the description gives the most critical operational fact (time duration) and the allowlist constraint. However, it omits any statement about what the crawl updates or how it relates to sibling tools, making the description feel incomplete for decision-making. The output schema covers return values, but the behavioral context is sparse.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides no parameter-level guidance whatsoever. Schema coverage is only 50%, with to_date and from_date described generically as calendar dates. Since the description does not compensate for this gap, parameter semantics are weak.
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 uses an explicit verb 'Run' with a specific resource ('allowlisted official-source crawlers') and notes the time duration. This clearly distinguishes it from sibling tools that list, search, or render experiences rather than execute crawls.
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 for refreshing experience data from official sources and mentions the 'allowlisted' prerequisite, giving some context. However, it does not explicitly state when to use this tool over alternatives like get_experience or search_nearby_experiences, nor does it provide any exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare read-only, idempotent, non-destructive behavior. The description adds the specific content returned (counts, last runs, gate state), which provides useful context beyond the structural annotations. No contradictions found.
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 sentence, front-loaded with the verb 'Return' and includes only essential information. It is concise and well-structured with no wasted words.
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 simplicity (no parameters, output schema exists), the description is sufficiently complete. It enumerates the returned data categories, and interpretation details of the gate state are likely covered by the output schema.
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 zero parameters, so the description naturally does not need to elaborate. The baseline of 4 applies since schema coverage is trivially 100% and there is no parameter-relevant information to add.
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 tool returns local database counts, last runs, and MCP refresh gate state. This distinguishes it from sibling tools that focus on experience data retrieval or refresh operations.
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 explicit guidance is provided about when to use this tool versus alternatives. The description only states what it returns, leaving the agent to infer it is a status check without mentioning specific scenarios like pre-refresh validation or troubleshooting.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so safety is covered. The description adds valuable behavioral context: the tool does NOT make source HTTP requests, which is a non-obvious trait that affects performance and data freshness. This goes beyond the schema and annotations, justifying a 4.
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, front-loaded sentence with clear verb and object. It contains no filler and immediately conveys the core purpose and a critical behavioral constraint. This is exemplary conciseness.
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 presence of an output schema, annotations, and with 4 parameters but no required ones, the description, while brief, covers the essential distinguishing factor (no source HTTP requests). Combined with structured data, it is sufficiently complete for an agent to select and use the tool, though it lacks explicit alternative references.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters2/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is low (25%), so the description should compensate by explaining parameter meanings beyond the schema. It does not; the description only mentions listing without network requests, leaving parameters like runnable_only and cursor unexplained. The schema provides some descriptions, but the low coverage means the description fails to add needed semantics, so a 2 is appropriate.
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 uses a specific verb ('List') and names the resource ('registered official sources') plus a key constraint ('without making source HTTP requests'). This distinguishes it from sibling tools like refresh_experience_sources, which likely perform network operations, and makes the tool's scope immediately clear.
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 provides a clear context for when to use this tool: it lists registered sources without triggering source HTTP requests. This implies a preference for offline listing, but it does not explicitly mention alternatives or when not to use it. Still, the absence of network behavior is a strong usage indicator, earning a 4 rather than a 3.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so safety profile is covered. The description adds a meaningful behavioral trait—the return excludes raw data—which is not in the annotations and helps the agent set expectations about the response. This goes beyond the structured data.
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 sentence, 14 words, and immediately states the action and resource. No fluff or redundant phrases. Perfectly front-loaded and efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter getter with a rich output schema and comprehensive annotations, the description fully covers what the agent needs to know: what it does, how to identify the event, and the one caveat (no raw data). No additional context is required.
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%, as the 'uid' parameter has a full description and pattern that matches the description's wording. The description adds no extra meaning beyond the schema—it repeats the same information ('public 24-character event ID'). Baseline 3 is appropriate.
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 uses a specific verb ('Get') and identifies the resource ('stored event') and the exact identifier mechanism ('public 24-character event ID'). It also adds a distinguishing qualifier ('without raw data') that separates it from sibling tools. This is clear and specific.
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 clearly implies the usage context: when you have a public event ID and need a single event. However, it does not explicitly name alternatives or state when not to use it. The distinction 'without raw data' hints at a differentiator but isn't an explicit exclusion.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![kids-experience-radar MCP server](https://glama.ai/mcp/servers/kimtami/kids-experience-radar/badges/card.svg)](https://glama.ai/mcp/servers/kimtami/kids-experience-radar)

Score Badge

Copy to your README.md:

[![kids-experience-radar MCP server](https://glama.ai/mcp/servers/kimtami/kids-experience-radar/badges/score.svg)](https://glama.ai/mcp/servers/kimtami/kids-experience-radar)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

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/kimtami/kids-experience-radar'

If you have feedback or need assistance with the MCP directory API, please join our Discord server