This server identifies LEGO items from images using the Brickognize API and provides detailed information via the Rebrickable API.
Recognition
Health check (brickognize_health): Verify the Brickognize API is online
Identify any item (brickognize_identify): Recognize an unknown LEGO item (part, set, minifigure, or sticker) from a photo
Identify a part (brickognize_identify_part): Precisely identify a specific brick or element
Identify a set (brickognize_identify_set): Recognize a LEGO set from its box, model, or instructions
Identify a minifigure (brickognize_identify_fig): Identify a specific minifigure
Batch identify (brickognize_batch_identify): Process up to 20 images in parallel in a single call
Lookup (requires Rebrickable API key)
Part details (brickognize_part_details): Available colors and which sets contain a part
Batch part details (brickognize_batch_part_details): Retrieve details for multiple parts at once
Set details (brickognize_set_details): Year, theme, and full parts inventory
Minifigure details (brickognize_minifig_details): Minifigure info and which sets it appears in
Additional Features
Accepts local JPEG, PNG, or WebP files via absolute paths
Configurable caching (none, in-memory, or SQLite) for Rebrickable API responses
Cache clearing via brickognize_cache_clear
Optional raw API response output for debugging
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Brickognize MCP Server Identify the LEGO set in /Users/me/Desktop/lego_box.jpg"
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.
Identify LEGO parts, sets, and minifigures from images — as a CLI tool or an MCP server for AI assistants.
Powered by the Brickognize API and Rebrickable.
Huge thanks to Piotr Rybak for creating the Brickognize service and making LEGO recognition accessible to everyone!
npm install -g brickscope
brickscope identify photo.jpg --type part
brickscope part 3001 --color Black
brickscope set 75192
brickscope minifig fig-012805Or run without installing: npx brickscope identify photo.jpg
Related MCP server: vision-mcp
For AI assistants (Claude, Cursor, etc.), add to your MCP config:
{
"mcpServers": {
"brickscope": {
"command": "npx",
"args": ["-y", "brickscope", "mcp"],
"env": {
"REBRICKABLE_API_KEY": "your-key-here",
"BRICKOGNIZE_CACHE": "sqlite"
}
}
}
}brickscope config initCreates ~/.config/brickscope/config.json with your Rebrickable API key and cache settings.
Variable | Default | Description |
| — | Free API key from rebrickable.com/api. Required for lookup tools. |
|
| Cache mode: |
Environment variables take priority over the config file.
Image recognition — identify parts, sets, minifigures, and stickers from photos
Batch processing — identify multiple images in parallel
Part lookup — colors, set appearances via Rebrickable
Set inventory — full parts list, year, theme, piece count
Minifigure lookup — details and set appearances
Caching — in-memory or SQLite cache for Rebrickable API responses
Config file — save API key and preferences once, use everywhere
See the examples folder for prompt templates.
npm install
npm run build
npm run dev # Watch mode
npm test # Unit + integration tests
npm run lint # ESLint
npm run format # PrettierMIT
Check whether the Brickognize image recognition API is online and responsive. Call this before recognition if you suspect the service might be down. Takes no parameters.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
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.
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.
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.
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.
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.
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.
Identify any LEGO item (part, set, minifigure, or sticker) from a photograph. Use this when the item type is unknown or the image may contain multiple types.
Provide imagePath — absolute path to a local image file (JPEG, PNG, or WebP). Returns top matches with confidence scores, IDs, names, categories, and links to BrickLink/BrickOwl.
| Name | Required | Description | Default |
|---|---|---|---|
| imagePath | No | Absolute path to a local image file (JPEG, PNG, or WebP). | |
| includeRaw | No | When true, includes the raw Brickognize API response alongside formatted results. Useful for debugging. |
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.
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.
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.
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.
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.
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.
Identify a LEGO minifigure from a photograph. Use instead of brickognize_identify when you know the image shows a minifigure.
Provide imagePath — absolute path to a local image file (JPEG, PNG, or WebP). Returns matched minifigures with IDs, names, confidence scores, and links.
| Name | Required | Description | Default |
|---|---|---|---|
| imagePath | No | Absolute path to a local image file (JPEG, PNG, or WebP). | |
| includeRaw | No | When true, includes the raw Brickognize API response alongside formatted results. Useful for debugging. |
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.
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.
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.
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.
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.
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.
Identify a specific LEGO part/brick/element from a photograph. Use instead of brickognize_identify when you know the image shows a single LEGO piece for more accurate results.
Provide imagePath — absolute path to a local image file (JPEG, PNG, or WebP). Returns matched parts with IDs, names, confidence scores, and links.
| Name | Required | Description | Default |
|---|---|---|---|
| imagePath | No | Absolute path to a local image file (JPEG, PNG, or WebP). | |
| includeRaw | No | When true, includes the raw Brickognize API response alongside formatted results. Useful for debugging. |
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.
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.
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.
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.
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.
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.
Identify a LEGO set from a photograph of its box, assembled model, or instructions. Use instead of brickognize_identify when you know the image shows a LEGO set.
Provide imagePath — absolute path to a local image file (JPEG, PNG, or WebP). Returns matched sets with set numbers, names, confidence scores, and links.
| Name | Required | Description | Default |
|---|---|---|---|
| imagePath | No | Absolute path to a local image file (JPEG, PNG, or WebP). | |
| includeRaw | No | When true, includes the raw Brickognize API response alongside formatted results. Useful for debugging. |
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.
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.
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.
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.
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.
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.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.0brickognize_healthbrickognize_identifybrickognize_identify_figbrickognize_identify_partbrickognize_identify_setThe 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.
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.
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.
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.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
OCR, transcription, file extraction, and image generation for AI agents via MCP.
Provides data for LEGO sets, minifigures, parts and elements. Not affiliated with LEGO® Group.
OCR.space MCP — wraps the OCR.space API (ocr.space) for image/PDF → text OCR.
AI-powered image processing via GPU. Remove backgrounds and upscale images (2x/4x) directly from any MCP client. OAuth 2.1 authenticated, returns processed images inline with download links. Free credits on signup at maskr.io.
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
