Brickognize MCP Server

by NazarLysyi

Overview Schema Related Servers Score Discussions

TypeScript

Local

Server Quality Checklist

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

Latest release: v1.0.0
Disambiguation4/5
The tools are mostly distinct with clear purposes: health check, general identification, and specialized identification for minifigures, parts, and sets. However, there is some overlap between brickognize_identify and the specialized tools, as the general tool can also identify these items, potentially causing confusion about when to use which. The descriptions help clarify, but the overlap exists.
Naming Consistency5/5
All tool names follow a consistent pattern: they start with 'brickognize_' followed by a verb or verb phrase (e.g., 'health', 'identify', 'identify_fig', 'identify_part', 'identify_set'). This snake_case naming is uniform across all tools, making them predictable and easy to understand.
Tool Count5/5
With 5 tools, the count is well-scoped for the server's purpose of LEGO item recognition. It includes a health check and multiple identification tools covering different item types, which is appropriate and manageable without being too sparse or overwhelming.
Completeness4/5
The tool set covers the core functionality of checking service health and identifying various LEGO items (general, minifigures, parts, sets), which aligns well with the domain. A minor gap is the lack of tools for additional operations like batch processing or detailed metadata retrieval, but the provided tools support the main workflows effectively.
Average 4.5/5 across 5 of 5 tools scored.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- 0 commits in the last 12 weeks
- No stable releases found
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
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 annotations already provide strong behavioral hints (readOnly, openWorld, idempotent, non-destructive). The description adds valuable context beyond this: it specifies the return format ('top matches with confidence scores, IDs, names, categories, and links to BrickLink/BrickOwl') and mentions the tool's capability to handle multiple item types, which is not covered by annotations. No contradiction with annotations exists.
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 well-structured. The first sentence states the core purpose, the second provides usage guidelines, and the third outlines parameters and return values. Every sentence adds essential information with zero waste, making it easy for an AI agent to parse quickly.
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 moderate complexity (image-based identification with multiple item types), rich annotations (covering safety and behavior), and no output schema, the description is largely complete. It explains the purpose, usage context, input requirements, and return format. However, it lacks details on error handling or limitations (e.g., image quality requirements), leaving minor gaps for an agent to infer.
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 (imagePath and includeRaw). The description mentions imagePath with format details (JPEG, PNG, or WebP) but adds no new semantic information beyond what's in the schema. For includeRaw, it explains its purpose ('useful for debugging'), which slightly enhances understanding but is largely redundant with the schema's description. Baseline 3 is appropriate given 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 verb 'identify' and the resource 'LEGO item (part, set, minifigure, or sticker)' from a photograph. It explicitly distinguishes this tool from its siblings by stating 'when the item type is unknown or the image may contain multiple types,' contrasting with the specialized sibling tools for specific item types.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool: 'when the item type is unknown or the image may contain multiple types.' This clearly differentiates it from the sibling tools (brickognize_identify_fig, brickognize_identify_part, brickognize_identify_set) that are for specific known item types, offering clear alternatives.
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?
The description adds valuable context beyond the annotations by specifying the return format ('matched minifigures with IDs, names, confidence scores, and links'), which is not covered by the annotations. The annotations already indicate it's a safe, read-only operation (readOnlyHint: true, destructiveHint: false), so the description appropriately focuses on output details rather than repeating safety information.
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 front-loaded with the core purpose, followed by usage guidance and key details about input and output. Every sentence serves a distinct purpose: the first states what the tool does, the second provides usage context, and the third covers input requirements and return values. There is no wasted text.
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 lack of an output schema, the description compensates by detailing the return format. It covers the tool's purpose, usage context, input requirements, and output structure. However, it doesn't mention potential limitations (e.g., image quality requirements, confidence thresholds) or error cases, which could be helpful for a tool performing image recognition.
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?
With 100% schema description coverage, the input schema fully documents both parameters (imagePath and includeRaw). The description mentions imagePath but doesn't add semantic details beyond what's in the schema. It doesn't explain includeRaw at all, relying entirely on the schema. This meets 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 ('Identify a LEGO minifigure from a photograph') and distinguishes it from sibling tools by explicitly mentioning when to use it instead of 'brickognize_identify'. It specifies the resource (LEGO minifigure) and the input type (photograph), making the purpose unambiguous and differentiated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool ('Use instead of brickognize_identify when you know the image shows a minifigure'), clearly differentiating it from a sibling alternative. This direct comparison helps the agent make informed decisions about tool selection based on context.
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 cover key behavioral traits (read-only, open-world, idempotent, non-destructive), so the bar is lower. The description adds value by specifying acceptable image sources (box, assembled model, instructions) and the return format (matched sets with numbers, names, confidence scores, links), which are not covered by annotations. It does not contradict annotations, as 'identify' aligns with read-only operations.
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 front-loaded with the core purpose in the first sentence, followed by usage guidance and parameter/return details. Every sentence earns its place by providing essential information without redundancy, making it highly efficient and well-structured.
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 moderate complexity (2 parameters, 100% schema coverage, annotations provided, no output schema), the description is mostly complete. It covers purpose, usage, parameters, and returns, but lacks details on error handling or limitations (e.g., image size constraints). With annotations handling safety and idempotency, it's sufficient but not exhaustive.
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 baseline is 3. The description adds minimal semantics beyond the schema: it mentions 'imagePath' and repeats the file format (JPEG, PNG, or WebP), which is already in the schema, and does not elaborate on 'includeRaw'. Thus, it meets the baseline without significant added value.
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 ('Identify a LEGO set from a photograph') and resource ('LEGO set'), distinguishing it from siblings like 'brickognize_identify_fig' or 'brickognize_identify_part' by specifying the target is a set. It explicitly mentions acceptable image types (box, assembled model, or instructions), making the purpose highly specific and differentiated.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool vs. alternatives: 'Use instead of brickognize_identify when you know the image shows a LEGO set.' This directly addresses sibling tools and clarifies the context for selection, offering clear alternatives and 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 cover read-only, open-world, idempotent, and non-destructive behavior, so the description doesn't need to repeat these. However, it adds valuable context about the return format ('Returns matched parts with IDs, names, confidence scores, and links') and the tool's specialization for single-piece identification, which enhances understanding beyond annotations.
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 front-loaded with the core purpose, followed by usage guidance and parameter/return details in two concise sentences. Every sentence adds value without redundancy, making it efficient and well-structured.
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?
Given the annotations cover safety and behavioral traits, the schema fully describes parameters, and the description clarifies usage context and return format, this is complete for an identification tool. No output schema exists, but the description adequately outlines what to expect in results.
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 mentions 'Provide imagePath' and briefly notes the return format, but doesn't add significant semantic details beyond what the schema provides. This meets 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 ('Identify a specific LEGO part/brick/element from a photograph') and distinguishes it from a sibling tool ('Use instead of brickognize_identify when you know the image shows a single LEGO piece for more accurate results'). It specifies both the verb (identify) and resource (LEGO part/brick/element) with precise scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit guidance on when to use this tool versus alternatives: 'Use instead of brickognize_identify when you know the image shows a single LEGO piece for more accurate results.' This directly addresses sibling tool differentiation with clear context for selection.
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 provide strong behavioral hints (readOnly, openWorld, idempotent, non-destructive). The description adds valuable context by explaining the tool's purpose as a pre-recognition health check, which helps the agent understand when to use it. However, it doesn't mention potential response formats or error conditions that could occur if the service is down.
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 sentences) and front-loaded with the core purpose. Every sentence earns its place: the first explains what the tool does, and the second provides usage guidance. There is zero wasted text.
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 (0 parameters, no output schema) and rich annotations, the description is mostly complete. It covers purpose and usage well. However, it doesn't describe what the output might look like (e.g., success/failure indicators), which could be helpful since there's no 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 0 parameters with 100% schema description coverage. The description explicitly states 'Takes no parameters,' which adds clarity beyond the empty schema. This is helpful for the agent to understand there are no inputs required, though the schema already indicates this.
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 ('Check whether the Brickognize image recognition API is online and responsive') and the resource ('Brickognize image recognition API'). It distinguishes from sibling tools (which perform recognition tasks) by focusing on health/availability rather than image identification.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool ('Call this before recognition if you suspect the service might be down'), providing clear context and distinguishing it from the sibling recognition tools. It effectively guides the agent on the appropriate scenario for invocation.
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:

[![brickscope MCP server](https://glama.ai/mcp/servers/NazarLysyi/brickscope/badges/card.svg)](https://glama.ai/mcp/servers/NazarLysyi/brickscope)

Score Badge

Copy to your README.md:

[![brickscope MCP server](https://glama.ai/mcp/servers/NazarLysyi/brickscope/badges/score.svg)](https://glama.ai/mcp/servers/NazarLysyi/brickscope)

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/NazarLysyi/brickscope'

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