MCPOSprint

by bhandzo

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: v1.0.0
Disambiguation5/5
Each tool has a clearly distinct purpose with no overlap: create_sample_files generates test files, info provides system status, print_only handles existing images, run_diagnostics performs health checks, task_cards_from_notion fetches from Notion, test_printer_connection verifies printer connectivity, and todo_list_cards_from_markdown processes markdown files. The descriptions reinforce these unique functions, making tool selection straightforward for an agent.
Naming Consistency4/5
The tools follow a consistent snake_case pattern throughout, with clear verb_noun structures (e.g., create_sample_files, test_printer_connection). However, there is a minor deviation with 'info' being a single noun instead of a verb_noun pair, which slightly breaks the pattern but does not significantly impact readability or predictability.
Tool Count5/5
With 7 tools, the count is well-scoped for the MCPOSprint server's purpose of managing task cards and printer operations. Each tool serves a specific role in the workflow—from setup and diagnostics to fetching tasks and printing—without redundancy, making the set efficient and focused.
Completeness4/5
The tool set covers the core workflows comprehensively: creating test files, system diagnostics, printer testing, fetching tasks from Notion, processing markdown, and printing. A minor gap exists in lacking a dedicated tool for updating or deleting generated files or cards, but agents can work around this using system commands or the existing tools for reprinting or regeneration.
Average 4.4/5 across 7 of 7 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 is failing
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

Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It describes what information is returned (version, dependencies, configuration, health) and specific checks performed, but does not mention potential side effects, error conditions, or performance characteristics like execution time or rate limits.
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 well-structured with clear sections (purpose, returns, checks) and uses bullet points for readability. While slightly verbose, every sentence adds value by explaining what the tool does and what information it provides. It could be more concise by combining some statements.
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?
Given the tool's complexity (system diagnostics with multiple checks) and no output schema, the description provides good coverage of what information is returned. However, it lacks details about the return format (e.g., JSON structure), error handling, or specific health indicators that would make it more complete for agent use.
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 with 100% schema description coverage, so the baseline is 4. The description appropriately does not discuss parameters, focusing instead on the tool's purpose and return values, which is correct for a parameterless tool.
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 purpose with specific verbs ('Get', 'Returns', 'Checks') and resources ('MCPOSprint server information and system status'). It distinguishes itself from siblings like 'test_printer_connection' by covering broader system diagnostics beyond just printer connectivity.
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 clear context for when to use this tool ('Essential for troubleshooting and verifying proper setup'), but does not explicitly state when not to use it or name specific alternatives among sibling tools. It implies usage for system health checks without exclusion guidance.
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?
With no annotations provided, the description carries full burden and does well by disclosing: real-time progress updates to prevent timeouts, required environment variables, and detailed progress tracking stages. It doesn't mention rate limits, authentication details beyond API key, or error handling, leaving some gaps.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness3/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is appropriately sized but not optimally structured. The core purpose is front-loaded, but the progress tracking details could be more concise. Some sentences like 'Provides real-time progress updates to prevent client timeouts' could be integrated more efficiently.
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 complexity (multi-step process with external API), no annotations, and an output schema (returns list of PNG paths), the description is mostly complete. It covers purpose, prerequisites, parameters, and behavior, though could benefit from more detail on error cases or output format specifics.
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?
Schema description coverage is 0%, but the description compensates by explaining the single parameter 'no_print' with its purpose (generate images without printing) and default value. However, it doesn't provide format details or constraints beyond what's implied.
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: 'Fetch today's tasks from Notion and generate thermal printer cards with QR codes.' It distinguishes from siblings like 'todo_list_cards_from_markdown' by specifying the Notion source and 'print_only' by including the full generation workflow.
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 clear context for when to use this tool (fetching tasks from Notion with specific statuses and generating cards) and mentions environment variable prerequisites. However, it doesn't explicitly state when NOT to use it or compare it to alternatives like 'todo_list_cards_from_markdown' beyond the source difference.
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?
With no annotations provided, the description carries the full burden. It discloses key behavioral traits: parsing markdown with specific format (## headers, - bullets), generating PNG images, optional printing with thermal printer, and priority handling. However, it lacks details on permissions, rate limits, or error handling, which are important for a tool with file I/O and printing capabilities.
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 appropriately sized and front-loaded with the core functionality in the first sentence. Each subsequent sentence adds value: parsing details, output format, printing control, priority handling, and an example. While efficient, the example section is slightly lengthy but still informative.
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 2 parameters with 0% schema coverage and no annotations, the description does well by explaining parameters, behavior, and output (list of PNG paths). The output schema exists, so return values don't need explanation. However, for a tool involving file parsing and printing, more context on error cases or dependencies would improve completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters5/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It fully explains both parameters: 'file' as a path to a markdown file relative to current directory, and 'no_print' as a boolean controlling printing behavior with default value. The example markdown format further clarifies input expectations, adding significant value beyond the bare schema.
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 purpose with specific verbs ('generate', 'print', 'parse') and resources ('task cards', 'markdown file', 'PNG images'). It distinguishes from siblings like 'print_only' (which only prints) and 'task_cards_from_notion' (which uses a different source) by specifying markdown parsing and optional printing.
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 clear context for when to use this tool (parsing markdown files with task lists) and implies when not to use it (e.g., for Notion-based tasks or printing-only operations). However, it doesn't explicitly name alternatives like 'task_cards_from_notion' or state exclusions, keeping it at a 4.
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?
With no annotations provided, the description carries full burden and does well by disclosing key behavioral traits: it scans directories, supports specific formats (PNG, JPG, JPEG), prints in alphabetical order, and includes automatic paper cutting. However, it doesn't mention potential error conditions, permission requirements, or rate limits that would be helpful for a printing operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured and appropriately sized with zero wasted sentences. It front-loads the core purpose, provides usage context, documents the parameter, return value, and behavioral details in clear sections. Every sentence earns its place by adding valuable information.
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 (directory scanning, file format handling, printing operations) and the presence of an output schema (which handles return values), the description is quite complete. It covers purpose, usage, parameters, formats, and behavioral details. The main gap is lack of error handling or permission information, but overall it provides good context for agent use.
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?
With 0% schema description coverage for the single parameter, the description compensates well by explaining what 'directory' means ('Path to directory containing image files') and providing context about what the tool does with that directory (scans it for image files). The description adds meaningful semantics beyond what the bare schema provides.
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 purpose with specific verbs ('send existing image files to the thermal printer without regenerating them') and distinguishes it from siblings by emphasizing it works with pre-existing files rather than generating new content. It explicitly mentions what resource it operates on (PNG/JPG image files) and the action (printing).
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 clear context for when to use this tool ('useful for reprinting previously generated cards or printing custom images you've created'), but doesn't explicitly state when not to use it or name specific alternatives among the sibling tools. It implies usage for existing images rather than generating new ones, which helps differentiate from tools like task_cards_from_notion.
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?
With no annotations provided, the description carries full burden and does well by specifying what the tool checks (6 specific diagnostic areas) and what it returns ('detailed diagnostic report as JSON object'). It doesn't mention performance characteristics, timeouts, or error handling, but provides substantial behavioral context for a diagnostic tool.
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 well-structured with clear sections (purpose, returns, diagnostic checks, use cases) and each sentence adds value. It could be slightly more concise by combining some lines, but overall it's efficiently organized with no redundant information.
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?
For a zero-parameter diagnostic tool with no annotations or output schema, the description provides excellent context: clear purpose, detailed scope of checks, return format, and specific usage guidelines. The only minor gap is not explicitly stating what happens if diagnostics fail or providing example output structure.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so the baseline would be 4. The description appropriately doesn't discuss parameters since none exist, focusing instead on the tool's comprehensive diagnostic nature and use cases.
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 purpose with specific verbs ('perform comprehensive system diagnostics', 'runs a complete health check') and identifies the target system ('MCPOSprint setup'). It distinguishes from siblings by focusing on comprehensive diagnostics rather than specific functions like printing or file creation.
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 provides three specific use cases in a 'Use this when:' section: first-time setup, troubleshooting printing/Notion issues, and verifying configuration after changes. This gives clear guidance on when to invoke this tool versus alternatives like test_printer_connection or other siblings.
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?
With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes what the tool does (attempts USB connection, sends test command), what it returns (success/failure message), and what it checks (USB detection, command response, initialization). However, it doesn't mention potential side effects like printer initialization noise or timeouts, leaving minor gaps.
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 well-structured with clear sections (purpose, usage, returns, checks, troubleshooting), but could be slightly more concise by combining some bullet points. Every sentence adds value, and it's front-loaded with the core purpose, though minor redundancy exists in the troubleshooting list.
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 tool's diagnostic complexity, no annotations, and the presence of an output schema (which handles return values), the description is complete. It covers purpose, usage, behavior, checks, and troubleshooting steps, providing all necessary context for an agent to invoke it correctly without over-explaining.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has 0 parameters with 100% schema description coverage, so the baseline is 4. The description appropriately doesn't discuss parameters since none exist, and instead focuses on the tool's functionality and troubleshooting context, which adds value beyond the empty schema.
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 ('verify that your thermal printer is connected and responding'), identifies the resource ('ESC/POS thermal printer'), and distinguishes it from sibling tools like 'print_only' by focusing on connection testing rather than actual printing. The purpose is unambiguous and well-defined.
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 ('Use this to troubleshoot connection issues before printing actual content'), provides a clear alternative scenario (if this fails, check specific items), and distinguishes it from other tools by its diagnostic nature. The guidance is comprehensive and actionable.
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?
With no annotations provided, the description carries full burden and does well by disclosing key behaviors: it creates a file in the current directory, includes specific content details (multiple task sections, priority examples, formatting), and mentions configuration via environment variables. It doesn't cover potential errors or file overwriting behavior, keeping it from a perfect score.
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?
Well-structured with clear sections (purpose, file details, usage guidance). Every sentence adds value: explains what it does, what the file contains, how to use it, and configuration method. No redundant or wasted text.
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 tool's simplicity (0 parameters, has output schema), the description is complete. It explains the purpose, output format, file contents, usage context, and configuration method. With an output schema present, it doesn't need to detail return values beyond mentioning 'Success message confirming file creation'.
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?
With 0 parameters and 100% schema coverage, the baseline would be 4. The description appropriately explains that no parameters are needed ('Configuration is handled via environment variables'), which adds useful context beyond the empty schema.
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 ('Generate a sample markdown file'), resource ('sample_cards.md'), and purpose ('to test MCPOSprint functionality'). It distinguishes itself from siblings like 'task_cards_from_notion' or 'todo_list_cards_from_markdown' by focusing on creating a test file rather than processing external sources.
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?
Explicitly states when to use this tool ('Perfect for testing your setup or learning the markdown format') and provides a clear alternative ('Use the generated file with process_static_cards tool to test printing'). It also distinguishes from siblings by indicating this is for sample generation rather than actual task processing.
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:

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

Score Badge

Copy to your README.md:

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

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/bhandzo/mcposprint'

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