@mager/loooom-mcp
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., "@@mager/loooom-mcpsearch for japanese language skills"
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.
@mager/loooom-mcp
An MCP (Model Context Protocol) server for Loooom — the Claude Code plugin/skill marketplace. Lets AI agents discover, search, and explore skills from the Loooom marketplace.
What is Loooom?
Loooom is a marketplace for Claude Code plugins and skills. This MCP server gives AI agents direct access to browse and find skills they can install.
Related MCP server: skillsmp-mcp-server
Usage
npx (no install required)
npx @mager/loooom-mcpGlobal install
npm install -g @mager/loooom-mcp
loooom-mcpClaude Desktop Configuration
Add to your claude_desktop_config.json:
{
"mcpServers": {
"loooom": {
"command": "npx",
"args": ["-y", "@mager/loooom-mcp"]
}
}
}Config file locations:
macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.json
Available Tools
Tool | Description |
| List all skills (name, description, category, version, author, homepage) |
| Filter skills by query string and optional category |
| Get full details for a single skill by name |
| List all unique categories with skill counts |
| Get the Claude Code install command for a skill |
Tool Examples
List all skills:
Use the list_skills tool to show me what's available on Loooom.Search for language skills:
Use search_skills with query="japanese" to find language learning skills.Install a skill:
Use get_install_command for "beginner-japanese" to get the install command.Returns: /plugin marketplace add mager/loooom beginner-japanese
Data Source
The skill catalog is fetched at runtime from:
https://raw.githubusercontent.com/mager/loooom/main/.claude-plugin/marketplace.jsonThe catalog is cached in memory and refreshed every 5 minutes. Failures fall back to cached data gracefully.
Development
git clone https://github.com/mager/loooom-mcp
cd loooom-mcp
npm install
npm run build
npm startLicense
MIT
Available Tools
5 toolsget_install_commandB
Get the Claude Code install command for a skill
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | The skill name to install (e.g. 'beginner-japanese') |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
There are no annotations provided, so the description carries the full burden of behavioral disclosure. The description simply says 'Get the Claude Code install command for a skill' and offers no detail on side effects, return format, error handling, or permissions. The behavior is as ambiguous as a generic getter.
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 a single, focused sentence that immediately states the tool's purpose. There is no extraneous information or filler. It is optimally concise for the simple operation it describes.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no annotations or output schema, the description is the only context provided. It explains what the tool does but omits crucial details such as what the install command output looks like, whether the skill must already exist, or any usage constraints. The minimal description is insufficient for an agent to fully understand the tool's behavior and return value.
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 input schema already provides a complete description of the 'name' parameter with an example ('beginner-japanese'), so schema coverage is 100%. The tool description adds no additional parameter semantics, which is acceptable given the high coverage. Baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific action ('Get') on a specific resource ('the Claude Code install command for a skill'). It clearly distinguishes itself from sibling tools like get_skill, which likely retrieves skill details rather than the install command. The verb and object are precise and non-tautological.
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 no guidance on when to use this tool versus alternatives. It does not mention sibling tools or any exclusions, leaving the agent to infer usage solely from the tool name and one-line description. No contextual hints about prerequisites or situations are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_skillA
Get full details for a single skill by name
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | The exact skill name (e.g. 'beginner-japanese') |
TDQS
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. 'Get full details' implies a safe read operation, but it does not explicitly state that it is read-only, what the response contains, or how errors are handled if the skill does not exist. This is adequate but not rich.
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 a single, focused sentence that directly states the tool's purpose without any unnecessary words or repetition. It is effectively front-loaded and earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one parameter and no output schema, the description sufficiently covers the purpose and parameter. It does not explicitly enumerate what 'full details' includes, but this is a minor gap given the tool's simplicity.
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 input schema already fully documents the single 'name' parameter with an example ('beginner-japanese'), and the description's 'by name' adds no new semantics. With 100% schema coverage, the description appropriately relies on the schema for parameter understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Get' and clearly identifies the resource ('full details for a single skill') and the access method ('by name'). It distinguishes itself from sibling tools like list_skills and search_skills, which focus on listing or searching rather than retrieving a single skill's details.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly implies the tool is for when you need full details of a known skill by its exact name. However, it does not explicitly compare to alternatives like search_skills or state when not to use it, so it lacks explicit exclusions but provides sufficient context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_categoriesA
List all unique skill categories with skill counts
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the burden of disclosure. It clearly states that the tool lists all unique categories and includes counts, which implies a read-only operation with no side effects. However, it does not mention ordering, pagination, or any potential limitations, though these are likely not relevant for such a simple tool.
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 a single, concise sentence that front-loads the action and resource. It contains no filler and every word contributes meaning, earning a perfect score.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with no parameters and no output schema, this description is complete. It conveys the tool's purpose, the nature of its output (unique categories with counts), and implies its read-only behavior. There is no missing information that would prevent an agent from using it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, and schema coverage is effectively 100%. According to the guideline, a baseline of 4 is appropriate when no parameters exist, as there is no parameter information for the description to add beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'List', the resource 'unique skill categories', and the scope 'all' with the additional detail of 'skill counts'. This clearly distinguishes it from sibling tools like list_skills, which list skills rather than categories.
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 implies usage: when you need to see skill categories and their counts, use this tool. However, it does not explicitly contrast with alternatives like list_skills or search_skills, leaving the decision to the agent's inference from sibling names.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_skillsA
List all available skills/plugins from the Loooom marketplace
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden. It indicates the operation is a read-only list, but does not disclose potential behaviors such as network dependency, pagination, or response format. The source ('from the Loooom marketplace') adds some context, but the description is otherwise minimal.
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 a single, clear sentence with no unnecessary words. It front-loads the action ('List all') and the object, making it immediately parseable.
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 annotations, no output schema), the description adequately states its purpose. Some might expect a note about the return format, but for a list-all tool the phrase 'available skills/plugins' sufficiently implies a list of those items.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so per the rubric the baseline is 4. The description does not need to explain any parameters, and the empty input schema is fully consistent. No additional parameter info is required.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'List' and identifies the resource as 'all available skills/plugins from the Loooom marketplace'. This clearly distinguishes it from sibling tools like search_skills (which searches) and get_skill (which retrieves a single item).
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 phrase 'all available' provides clear context that this tool is for obtaining the complete catalog, implicitly differentiating it from the more selective search_skills. However, it does not explicitly mention when to avoid using it or name alternatives, so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
search_skillsA
Search skills by query string (matches name, description, keywords) with optional category filter
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes | Search query to match against name, description, and keywords | |
| category | No | Optional category to filter by (e.g. 'languages', 'tools') |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the transparency burden. It discloses how matching works (against name, description, keywords) and the category filter, which is useful. However, it does not mention result pagination, limits, case sensitivity, or whether the search is fuzzy/exact, leaving some behavioral ambiguity.
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 a single, front-loaded sentence with no unnecessary words. It states the primary action, the matching criteria, and the optional filter in a compact and scannable way.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a relatively simple search tool with no output schema or annotations, the description covers the core functionality (search by query, optional category filter). It could provide more context on return format or when to use over sibling tools, but given the low complexity, it is reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides full descriptions for both parameters (query and category), and the description largely repeats that information. Since schema coverage is 100%, the description adds no new semantic detail beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action: 'Search skills by query string', and specifies the search scope (matches name, description, keywords) and an optional category filter. This distinctively separates it from siblings like list_skills (list all) and get_skill (retrieve specific).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context for when to use this tool (search by query, optionally filtered by category), but does not explicitly mention alternatives or exclusions relative to sibling tools. No 'use X instead' guidance is provided, but the context is sufficient for basic selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
5 tool updates
v0.1.0- First observed
get_install_command - First observed
get_skill - First observed
list_categories - First observed
list_skills - First observed
search_skills
TDQS
Each tool targets a distinct operation: listing all skills, searching with filters, fetching details by name, listing categories, and retrieving install commands. No two tools have overlapping responsibilities, so an agent can easily select the right one.
All tool names follow a clear verb_noun pattern (list_skills, search_skills, get_skill, list_categories, get_install_command). The naming is entirely consistent and predictable.
With 5 tools, the surface is well-scoped for a read-only marketplace browsing purpose. Each tool provides a necessary and distinct function without unnecessary bloat.
The tools cover the full browsing lifecycle: discover skills (list/search), inspect details (get), navigate by category (list_categories), and obtain install commands. There are no obvious gaps for the intended domain.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Marketplace of MCP servers and agent skills, free and paid, where developers publish and monetise.
Capability registry for the agentic economy. Semantic search over verified MCP server listings.
Search engine for AI agents to find MCP servers, A2A agents, and skills on their own.
- UnifAPIOAuthcom.unifapi
Hosted MCP server for live public-data APIs and Skills for AI agents.
Related MCP Servers
AlicenseAqualityFmaintenanceMCP server for discovering and installing AI agent skills from agentskill.sh. Search skills across platforms, browse trending skills, and install them with built-in security scanning.4133MIT- AlicenseAqualityCmaintenanceThis MCP server enables AI agents to search, discover, and install skills from the SkillsMP marketplace, with support for keyword and semantic search, skill content retrieval, and installation to various coding agents.51,6473MIT
- AlicenseNot gradedqualityCmaintenanceMCP server for SkillDB that enables AI assistants to search, load, and manage AI agent skills directly.97MIT
- AlicenseNot gradedqualityDmaintenanceA powerful MCP server that brings the skills.sh ecosystem directly to your AI agents, enabling effortless discovery, installation, and management of skills.1MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
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/mager/loooom-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server